magic-agent 2.6.0 → 2.6.3

package/client-ui-mobile/index.html

@@ -38,43 +38,127 @@
 <!-- 脚本页（「发现 → 脚本」）是独立子页面：样式在 scripts.css、结构/逻辑在 scripts.js。
      本文件只给两个空容器与一次 mount，不再混入这一页的实现。 -->
 <link rel="stylesheet" href="scripts.css">
+<!-- 应用页（「发现 → 应用」）是独立子页面：样式在 apps.css、结构/逻辑在 apps.js。 -->
+<link rel="stylesheet" href="apps.css">
 <style>
 /* ===== 令牌：几何/字阶照 ZCode 安卓端；颜色契约见下 =====
    ⚠️ 默认 = 暗色。浅色仍逐字段对齐 ZCode Color.kt；
       暗色自 2026-10-24 起改为掌天瓶墨绿系（用户：「这个深色跟掌天瓶主色不搭」）。 */
 :root{
   color-scheme:dark;
-  /* 2026-10-24 用户定稿：「这个深色跟掌天瓶主色不搭」——
-     暗色不再照抄 ZCode 的中性蓝灰（#111827/#1F2937），整套换成**掌天瓶墨绿系**：
-     页面底色 = 近乎黑的墨绿，卡片往上提一档，分界线带一层淡玉光。
-     色相统一压在绿（H≈158°），亮度层级与原来一致，只换色相，不动对比关系。 */
-  --canvas:#0B1512;                                   /* background = 掌天瓶墨绿底 */
+  /* ── 安全区下沿：**走变量、不走 env()**（2026-10-26 用户：「常规状态和新建任务输入的时候
+     底栏高度样式都不一致」）──
+     `env(safe-area-inset-bottom)` 在键盘弹起时会**从 34 变成 0**（Android WebView 的
+     adjustResize 把导航栏让位给键盘，这条 inset 就归零了）。于是同一个底栏：
+       常规（picker 收起）= 56 + 34 = 90px，下沿还留出 34px 的栏面给 home indicator；
+       一点输入框     = 56 + 0  = 56px，栏体凭空矮 34px、图标整体往下掉 17px，
+                        弧线也被挤到图标上 —— 就是「两种状态样式不一样」。
+     现在统一读 `--sab`：它由页脚那段脚本量出来并**在键盘弹起期间冻结**，
+     所以两种状态下栏体永远是 56 + 34。想知道它怎么冻的，看 `--sab` 那段脚注。 */
+  --sab:env(safe-area-inset-bottom, 0px);
+  /* ── 底栏三个几何常量：全部**从栏底往上量**，彼此不推算 ──
+     （2026-10-26 用户：「底栏高度固定 图标距离底部的距离固定 弧线距离底部的距离也固定」）
+
+     以前这三个数是**互相算出来**的，所以改一个会连带漂三个：
+       · 栏高 = `56px + sab`（写死在 height 里，56 这个数字散落在注释和 composer 内边距中）
+       · 图标 = 在 56 的内容区里 `align-items:center` —— 距栏底 = (56 − 图标高)/2，
+                于是 26px 的器物离底 15、28px 的「我的」离底 14，**四枚不在一条线上**；
+       · 弧线 = 由 `AMP=14` 反推下沉 10.5，距栏底 = 56 − 10.5，而 56 又是上面那个数。
+
+     现在三个都独立、都从同一条基准（栏底）量起：
+       --bar-h    栏体内容区高度（不含安全区）→ 栏总高 = --bar-h + --sab
+       --ic-gap   图标**底边** → 栏底（四枚器物共用一条基线，与图标自身尺寸无关）
+       --arc-dip  弧线**最深处** → 栏底（端点恒定在栏顶，见 .bararc 脚本）
+     ⚠️ 改 --bar-h 只会把栏顶抬高/压低，图标与弧线相对栏底的位置一根毫毛不动。
+     ⚠️⚠️ --ic-gap 与 --arc-dip 的关系**不能只看弧线最深处**（2026-10-26 踩过）：
+        弧是「中间最低、两端最高」的浅盆，最深处落在 **FAB 中心的 x=W/2**，那里没有图标；
+        四枚图标在 x≈10%/30%/72%/92% 处，弧线到那里已经抬起来了。
+        所以**要逐个图标、按它自己的 x 求弧线 y** 再和「--ic-gap + 图标高」比：
+          390 宽实测（--ic-gap:15）：
+            x=39.5  弧 52.0  图标顶 41.0 → 净空 11.0
+            x=118.5 弧 47.1  图标顶 41.0 → 净空  6.1  ← 最紧
+            x=281.5 弧 47.1  图标顶 41.0 → 净空  6.1  ← 最紧
+            x=360.5 弧 52.0  图标顶 43.0 → 净空  9.0
+        ⚠️ 曾经误把「最深处」当基准，把 --arc-dip 降到 34 想「让弧更明显」——
+            结果 x=118.5/281.5 处的弧落到 37.3，**横穿两枚图标 3.7px**（用户：「弧线压住图标了」）。
+            那个误区是：以为最深处是全场最低点、只要它高于图标顶就安全；
+            实际上「距栏底」这个量**越小越低**，拿最深处(45.5)去比图标顶(41)看着危险，
+            而真正要防的是两侧上升段。
+        要改弧深，用 /tmp/pericon.mjs 那种**逐图标求弧线 y** 的算法复验，别用单一最深处。
+        若要弧更明显，同时下压 --ic-gap 或抬高 --bar-h，让「图标顶」也跟着抬。
+        ⚠️ 改 --ic-gap / 图标尺寸 / --bar-h，这里四个 x 的净空要重新算一遍。 */
+  --bar-h:56px;
+  --ic-gap:15px;
+  --arc-dip:45.5px;
+  /* 「＋」按钮底边 → 栏底。井半径 37 + 按钮半径 34 = 71，两者同心（见 .tabbar::before）。 */
+  --fab-gap:12px;
+  /* 暗色 = **掌天瓶墨绿系**（2026-10-24：「这个深色跟掌天瓶主色不搭」）。
+     ⚠️ 2026-10-25 修的是**可辨识度**，不是色相：原来整套是 H≈157 但**饱和度只有 25%**的
+     深灰绿（#0B1512/#14211C/#20322A）。那个饱和度在手机 OLED 上直接读成「黑」——
+     用户连着两轮反馈「深色皮肤还是没变」。逐像素实测当时改动只覆盖 1.76% 像素，
+     全落在 FAB 和警告框上，背景一个像素没动。
+     现在做两件事，缺一不可：
+       ① **把绿提到看得见**：canvas S 25%→60%、raised/subtle S 22~25%→37~38%。
+          低明度下饱和度是唯一能读出「这是墨绿不是黑」的东西。
+       ② **把层次拉开**：canvas↔raised 1.12（几乎同色，卡片立不起来）→ **1.34**，
+          raised↔subtle 1.23 → **1.33**。原来整屏读作一块平板，这才是「没变」的真根因。
+     明度仍压在 L4~L21，不刺眼；正文对 canvas 17.4、muted 对 raised 7.0，都远超 AA。
+     色相锁在 H142~154 一个族内，不引入第二个色源。
+
+     ⚠️ 2026-10-25 第二轮（用户：「深色皮肤继续完成全部配色优化」）—— 补上面这版没顾到的地方，
+     canvas 一个像素没动（仍是 #06180F），只校色相与「卡面本身」：
+       ① 半透明色块会串色相：alpha 叠加是平均，暖色压在墨绿底上会被拉回绿 —— 实测
+          warning 22% 叠 raised 出 H60 橄榄、fail 18% 出 H38 土黄、stop（暖灰）出 H138 绿灰：
+          三个「状态底」互相读不出区别，还和旁边真正的绿混在一起。现在状态底按色相显式给
+          （不再写 rgba(前景色,.18)）：叠完分别落在 warning H65/60、fail H8/18、stop H150/152，
+          与各自前景色同族（叠在 canvas 上比叠在卡面上更靠近本色 —— 卡面自己有 36% 的绿）。
+       ② 同色相三档收成一个族：原 canvas H150 / raised H144 / subtle H142，差 8° 在大色面上
+          会读成「两种绿」—— 统一 H150；code/canvas、bubble/raised 只差明度不再差色相。
+          顺带把卡面抬到 L17（#1B3A2B）：canvas↔raised 1.34 → 1.47，卡片立得起来一档。
+       ③ --running 与 --success 同为 #22C55E：按 H142/45% 族提亮成 #35D972（列表图标、
+          脚本页徽标、插件状态都用它），对 canvas 9.9 / raised 6.7，也不再和 --success 撞。
+       ④ --faint 在 raised 上只有 4.51（勉强贴着 AA 正文线 4.5）：第三级文字（时间、模块计数、
+          「我的」副说明）偏淡 —— 提到 #86A294（raised 4.51 / canvas 6.64）。⚠️ 卡面抬到 L17
+          之后它仍然只能压到 4.51：再往上就要和 --muted（6.37）撞档，所以这是「三级文字」的
+          地板 —— 小于 12px 的字别用 --faint，用 --muted。
+       ⑤ --tint-run 原来偏青（H164），跟运行图标 / 玉青对不上 —— 换成 Green A700 #00C853 20%：
+          叠出 H149 S47 的玉底，和主色同族。
+       ⑥ 错误卡三色（conversation.css 的 .notice / .permchip / .boot-err）是纯红 #FCA5A5，
+          在一屏墨绿里是唯一的暖色、也偏刺眼：换成同明度的硃砂珊瑚 #F9B4A4（H12）/ #F58E7A（H14），
+          红仍读得出是红；底 #3A1414 压成更正的暗硃砂（H357 → H0）。 */
+  --canvas:#06180F;                                   /* background = 掌天瓶墨绿底（不动） */
   --ink:#F2FBF5; --ink-soft:#DCEAE2; --muted:#A7BFB2; --faint:#7C9488;
-  --border:rgba(167,243,208,.12); --subtle:#20322A; --raised:#14211C;
+  --border:rgba(71,184,128,.18); --subtle:#213F2F; --raised:#1B3A2B;
   --primary-action:#6EE7A8; --on-primary-action:#07130E;               /* primary = 掌天瓶玉青（原 ZCode 品牌蓝） */
   /* 底栏「＋」凹槽的两件套，**必须按主题分别给**（`--fab-well` 槽底，`--fab-notch` 接触影满强度色）：
-     槽底不能用 `--canvas` —— 那是「页面底色」，暗色下 #0B1512 比栏面 #14211C 暗 14 阶，
+     槽底不能用 `--canvas` —— 那是「页面底色」，暗色下 #06180F 比栏面暗 11 阶，
      整圈会读成一道黑箍（比浮起来更假）。槽底该是**栏面稍暗一档**的同一个色系：
-     暗色 #14211C → #0F1B17（同色相压 4 阶），浅色 #FFFFFF → #EEF2F7（同色相压 8 阶，必须够，
+     暗色 raised #1B3A2B → #152E21（玉盘墨绿，压 4 阶），浅色 #FFFFFF → #EEF2F7（同色相压 8 阶，必须够，
      因为 248/250/252 与 255 只差 7 阶，直接用 canvas 等于没画）。 */
-  --fab-well:#0F1B17; --fab-notch:rgba(0,0,0,.22);
+  --fab-well:#152E1F; --fab-notch:rgba(0,0,0,.28);
   --app-shadow:rgba(0,0,0,.5);
+  /* 底栏弧面的填充（见 .bararc）。深色给**比自己更暗一档**的玉面：弧线投在它上面读得出
+     「一片面浮在页面之上」。浅色两个块都不给 → 落到 --raised（白栏面）+ 收掉投影，只留弧线。 */
+  --bar-fill:color-mix(in srgb,var(--raised) 82%,var(--canvas));
 
   /* 用户气泡 = surface/foreground：ZCode 的用户消息是**中性表面**不是品牌色气泡 */
-  --bubble:#15231E; --bubble-text:#F2FBF5;
-  --code:#070F0D; --status-neutral:#20322A; --status-neutral-text:#A7BFB2;
+  --bubble:#1B3B27; --bubble-text:#F2FBF5;
+  --code:#04110B; --status-neutral:#213F2F; --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 上颜色本身就是最强的辨识信号 —— 单色描边怎么调都读不出「法器」。 */
+     25px 上颜色本身就是最强的辨识信号 —— 单色描边怎么调都读不出「法器」。
+     ⚠️ 2026-10-25 第二轮量过丹血朱：原 #E23B2E 是 H5 的响亮红，压在墨绿底上只有 4.86 ——
+     对这种**只有 25px、只用来点缀**的图标色够用（对比度门限针对文字，不针对图形点缀），
+     所以保留没动。它只在底栏图标里出现，不参与任何文字 / 面板配色。 */
   --q-gold:#E8C77A; --q-blood:#E23B2E;
 
-  --md-body:#F2FBF5; --md-muted:#A7BFB2; --md-border:#25392F; --md-code-bg:#182720;
+  --md-body:#F2FBF5; --md-muted:#A7BFB2; --md-border:#2B5839; --md-code-bg:#1C3C27;
   --link:#6EE7A8; --prompt:#6EE7A8; --shimmer:#F2FBF5;
-  --panel:#14211C; --panel-border:#25392F;
+  --panel:#173322; --panel-border:#2B5839;
 
   /* 语义三态必须互相区分的（2026-10-25 深色配色量化发现）：
      `--running` 绿 / `--queued` 金 / `--warning` 琥珀 三个在屏幕上是**并排出现**的
@@ -85,21 +169,39 @@
      两者拉开到 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:#6EE7A8; --active:#FBBF24;
+  /* 错误三色（2026-10-25 第二轮）：纯红 #FCA5A5 / #F87171 → 硃砂珊瑚（同明度，H12 / H14）。
+     理由见上面第二轮第 ⑥ 条：红在一屏墨绿里本来就醒目，不需要再靠「纯红」加码。
+     底 #3A1414 对 error-text 9.1、icon 6.4。 */
+  --error-surface:#3A1414; --error-border:#7F1D1D; --error-text:#F9B4A4; --error-icon:#F58E7A;
+  --running:#35D972; --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);
+     浅色另给一份蓝底（见下面两个浅色块），保持 ZCode 那份观感不变。
+     ⚠️ 数值是按「叠完之后的色相」反推的（2026-10-25 第二轮），别随手改成 rgba(前景色,.18)：
+     那样叠完会串到别的色相（去青、发土、发绿），三个状态底互相分不清。 */
+  --tint-run:rgba(0,200,83,.20); --tint-wait:rgba(174,112,4,.22); --tint-done:rgba(34,197,94,.18);
   /* 排队 = 蓄势待发 → 鎏金（同浅色那份）。原来用紫 #8B5CF6，
      在墨绿底上没有任何亲缘色，一眼就是异物。 */
   --tint-queued:rgba(232,199,122,.16); --queued:#E8C77A;
+  --badge-accent:var(--warning);                       /* 需求页「待整理」徽标的主色（深色=琥珀 5.8） */
   /* 异常终态两档（2026-10-23 用户：「现在没有异常状态的颜色」）：
        · 失败（failed）→ 红：引擎报错结束，这条没跑完就没了，要人看一眼；
        · 已取消 / 已打断 / 断连（cancelled / interrupted / gone）→ 石褐：人为收工或进程
          被外部带走（服务重启、终端关闭），不是故障，所以不上红 —— 但也绝不能和
-         「正常结束」的绿或兜底的白同色。 */
-  --tint-fail:rgba(239,68,68,.18); --fail:#F87171;
-  --tint-stop:rgba(120,113,108,.24); --stop:#A8A29E;
+         「正常结束」的绿或兜底的白同色。
+     2026-10-25 第二轮：这两个底都是「反向补偿」过的层 —— 直接拿前景色做 rgba 会被墨绿底
+     拉走色相（实测失败出 H38 土黄、停/断连出 H138 绿灰），所以按叠完的落点反推：
+     失败底落在 H4/H3（硃砂粉），停/断连底落在 H150 中性玉灰。见上面第二轮第 ① 条。 */
+  --tint-fail:rgba(255,64,78,.22); --fail:#F87171;
+  --tint-stop:rgba(120,132,126,.26); --stop:#A8A29E;
+  /* 「整理失败」警告卡（reqs.css 用）的底与徽标底。**必须按主题分别给**：
+     浅色那两个式子是压 --raised(#FFFFFF) 出来的暖白；照抄到深色会变成橄榄绿（H99），
+     警告感全丢。深色这一版再往黄里走一档：底叠 --canvas 25% 落在 H73（和排队金 H45 拉开 28°）。
+     徽标若继续用「34% 半透明琥珀」，--ink 压上去只剩 3.2 —— 所以徽标改成实心琥珀层色、
+     文字改用 --canvas：墨字压琥珀 5.7，比原来的墨绿字压淡琥珀更清楚。
+     浅色两个块里钉回原写法（含 --warn-badge-text:--ink），保证浅色零变化。 */
+  --warn-surface:color-mix(in srgb,var(--warn-layer) 25%,var(--canvas));
+  --warn-layer:#B08A00;                                /* 反向补偿层：叠墨绿后落在 H73 */
+  --warn-badge:var(--warn-layer); --warn-badge-text:var(--canvas);
 
   /* ── 掌天瓶绿液（可选令牌，shared/conversation.css 用 `var(--q-bottle*, 兜底)` 取）──
      瓶是**玉**不是玻璃（见 conversation.js 的形制说明），所以颜色分两组：
@@ -108,12 +210,15 @@
        · 灵液 `--q-bottle-hi / / lo / deep`：液位以下的浓翠。
        · `--q-bottle-line` 是轮廓（比玉胎深一档的绿）、`--q-bottle-rim` 是边光/液面亮线/气泡
          （必须比 hi 更白，否则整只瓶会「发光过度」）、`--q-bottle-cork` 是木塞。
-     移动端的绿跟 --running 同族（#22C55E），兜底那份偏薄荷（#2ECB80），深色底上会发灰。 */
+     ⚠️ 这四个绿（hi / / lo / deep）是玉液的色阶，跟主题的 --running / --primary 无关，
+      浅色也继承这一份 —— 2026-10-25 第二轮没有动它们（只动了 line：H148 灰绿 → 并入 H150 族）。 */
   --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);
+  /* 玉胎三层（半透明）：叠在墨绿底上会被拽凉 —— 2026-10-25 第二轮把 G/B 往 H150 收了一点，
+     叠 canvas 出 H150~152（原来是 H143~145，比页面底色冷一档，读作「另一块玉」）。 */
   --q-bottle-jade-lo:rgba(8,96,60,.58);
 
   --r-card:16px; --r:12px; --r-full:999px;
@@ -149,6 +254,11 @@
     --activity:rgba(37,99,235,.08);
     /* 玉青选中（浅底沉一档，太浅会读不出「选中」） */
     --tab-on:#0C8F5C; --tab-on-bg:rgba(16,163,90,.10);
+    /* 底栏弧边（见 .bararc__s）：白栏面落在 #F8FAFC 的页面上只差 3 个色阶，只用 2px `--border`
+       画弧，弧只在中间（曲线压进栏里的那一段）看得见，两端 30% 一进屏就折平、直接消失 ——
+       键盘弹出时页面变矮、这 18px 弧就成了底栏唯一的样子，读出来就是「底栏没了」。
+       所以弧边单独给一档比 --border 深、比文字浅的灰。深色不用：玉面与页面之间本来就有明度阶梯。 */
+    --bar-edge:#CBD5E1;
     /* 浅底：鎏金要压暗一档才看得清，丹血朱提亮一点 */
     --q-gold:#B98A2E; --q-blood:#D13A2C;
     --md-body:#111827; --md-muted:#64748B; --md-border:#E2E8F0; --md-code-bg:#F1F5F9;
@@ -188,6 +298,10 @@
        这一轮深色把它改成深琥珀了，不钉就会连带把浅色的「待整理」徽标底色改深。
        --tint-done / --q-bottle* 同样没写，但那几个 :root 的值这轮没动，无需重复钉。 */
     --tint-wait:rgba(245,158,11,.20);
+    /* 警告卡底：浅色**钉住原写法**（压 --raised=#FFFFFF 的暖白）—— 深色那块把基底
+       换成了 --canvas，浅色不钉就会连带变深。 */
+    --warn-surface:color-mix(in srgb,var(--warning) 9%,var(--raised));
+    --warn-badge:color-mix(in srgb,var(--warning) 24%,transparent); --warn-badge-text:var(--ink);
   }
 }
 /* 手动主题：在「我的」页显式选了才生效（属性选择器优先级高于上面的 :root / media） */
@@ -203,6 +317,7 @@ html[data-theme="light"]{color-scheme:light;
   --activity:rgba(37,99,235,.08);
   /* 玉青选中（同 prefers-color-scheme:light 那一份） */
   --tab-on:#0C8F5C; --tab-on-bg:rgba(16,163,90,.10);
+  --bar-edge:#CBD5E1;                 /* 同 prefers-color-scheme:light 那一份 */
   --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;
@@ -226,6 +341,10 @@ html[data-theme="light"]{color-scheme:light;
   --queued:#8B5CF6; --tint-queued:rgba(139,92,246,.18);
   /* --tint-wait 钉回原值（理由见 prefers-color-scheme:light 那份） */
   --tint-wait:rgba(245,158,11,.20);
+  /* 警告卡底：浅色**钉住原写法**（压 --raised=#FFFFFF 的暖白）—— 深色那块把基底
+     换成了 --canvas，浅色不钉就会连带变深。 */
+  --warn-surface:color-mix(in srgb,var(--warning) 9%,var(--raised));
+  --warn-badge:color-mix(in srgb,var(--warning) 24%,transparent); --warn-badge-text:var(--ink);
   /* 中间 FAB 材质：浅色钉回原样（同 prefers-color-scheme:light 那份） */
   --fab-sheen:linear-gradient(178deg,rgba(255,255,255,.16),rgba(255,255,255,0) 60%);
   --fab-base:#22C55E;
@@ -239,38 +358,55 @@ html[data-theme="light"]{color-scheme:light;
    而是继续用浅色的值 —— 于是深色下出现蓝底头像（--tint-run 蓝）、暖米黄头像
    （--btn-me-bg 硬编码米黄）、紫排队（--queued 紫）。补全后两套手动主题都自洽。 */
 html[data-theme="dark"]{color-scheme:dark;
-  --canvas:#0B1512;
+  --canvas:#06180F;
   --ink:#F2FBF5; --ink-soft:#DCEAE2; --muted:#A7BFB2; --faint:#7C9488;
-  --border:rgba(167,243,208,.12); --subtle:#20322A; --raised:#14211C;
+  --border:rgba(71,184,128,.18); --subtle:#213F2F; --raised:#1B3A2B;
   --primary-action:#6EE7A8; --on-primary-action:#07130E;
-  --fab-well:#0F1B17; --fab-notch:rgba(0,0,0,.22);
+  --fab-well:#152E1F; --fab-notch:rgba(0,0,0,.28);
   --app-shadow:rgba(0,0,0,.5);
-  --bubble:#15231E; --bubble-text:#F2FBF5;
-  --code:#070F0D; --status-neutral:#20322A; --status-neutral-text:#A7BFB2;
+  --bar-fill:color-mix(in srgb,var(--raised) 82%,var(--canvas));
+  /* 底栏弧边（深色）：浅色块那档 #CBD5E1 会漏到这里 —— 那是给白栏面配的浅灰蓝，
+     压在墨绿玉面上就是**一道亮白曲线**横穿图标（2026-10-26 截图实测）。
+     深色要的是「玉面比页面亮一档」的**边缘微光**，不是分隔线：
+     用同色相、低不透明度（.28）提一档，弧线读得出走位又不抢图标。
+     见 .bararc__s 与 :root 里 --arc-dip 那段注释。 */
+  --bar-edge:rgba(110,231,168,.28);
+  --bubble:#1B3B27; --bubble-text:#F2FBF5;
+  --code:#04110B; --status-neutral:#213F2F; --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;
+  --md-body:#F2FBF5; --md-muted:#A7BFB2; --md-border:#2B5839; --md-code-bg:#1C3C27;
   --link:#6EE7A8; --prompt:#6EE7A8; --shimmer:#F2FBF5;
-  --panel:#14211C; --panel-border:#25392F;
+  --panel:#173322; --panel-border:#2B5839;
   /* 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:#6EE7A8; --active:#FBBF24;
+  --error-surface:#3A1414; --error-border:#7F1D1D; --error-text:#F9B4A4; --error-icon:#F58E7A;
+  --running:#35D972; --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 / 招标示 / 底栏法器 / 顶栏头像。
+     ⚠️ 状态 tint 的数值是「叠完之后的色相」反推的，见 :root 第一段的第二轮第 ① 条。 */
+  --tint-run:rgba(0,200,83,.20); --tint-wait:rgba(174,112,4,.22); --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;
+  --badge-accent:var(--warning);                       /* 需求页「待整理」徽标的主色（深色=琥珀 5.8） */
+  --tint-fail:rgba(255,64,78,.22); --fail:#F87171;
+  --tint-stop:rgba(120,132,126,.26); --stop:#A8A29E;
+  /* 警告卡两件（同 :root 深色那份，逐值相同） */
+  --warn-surface:color-mix(in srgb,var(--warn-layer) 25%,var(--canvas));
+  --warn-layer:#B08A00;
+  --warn-badge:var(--warn-layer); --warn-badge-text:var(--canvas);
+  --tint-queued:rgba(232,199,122,.16); --queued:#E8C77A;
+  --badge-accent:var(--warning);                       /* 需求页「待整理」徽标的主色（深色=琥珀 5.8） */
   --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);
+  /* 这三项 :root 里没有（:root 的 --gem-facet 是鎏金 #E8C77A）：深色头像的灵石刻面用页面底墨色，
+     浅色两块各自钉回鎏金 —— 所以这里必须写「深色那一版」。 */
   --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 用户：「浅色皮肤不变 改深色皮肤配色」）。
@@ -278,7 +414,7 @@ html[data-theme="dark"]{color-scheme:dark;
      同一个色相却高出 35 阶明度、40 阶饱和，读起来是一只**发光的塑料球**，
      也是整屏最刺眼的一处（截图实测，1.68 万像素是这个色）。
      深色改成「深玉盘」：径向从玉心 (#3FAE79) 落到墨底 (#093720)，明度压在
-     底栏栏面 (#14211C, L10) 与选中图标 (#6EE7A8, L67) 之间；
+     底栏栏面 (#173322, L14) 与选中图标 (#6EE7A8, L67) 之间；
      再补一圈 **1.5px 鎏金环** —— 主按钮的「这是可点的」不能靠更亮更大声，
      而是靠金环这个**形状**（金与墨绿是这套配色的互补对，底栏法器纹样本来就有点金）。
      玉光 halo 收到 .12：原来 .30 的 22px 绿晕是「发光」的另外一半原因。 */
@@ -395,9 +531,27 @@ textarea{font:inherit}
 .history__title--btn.is-open .history__title-chev{transform:rotate(180deg)}
 .history__disconnect{color:var(--primary-action);font-size:14px;font-weight:500;padding:8px 10px}
 .history__disconnect:disabled{color:var(--muted);opacity:.6}
-.history__list{flex:1;min-height:0;overflow-y:auto;padding:4px 10px calc(96px + env(safe-area-inset-bottom))}
+/* 列表底部留白：够「凸出的 ＋」+ 栏高 + 安全区。2026-10-26 起全走变量，
+   `--bar-h` 一改这里自动跟随（原来是写死的 96 = 56 + 34 + 6，改栏高就会压住最后一行）。 */
+.history__list{flex:1;min-height:0;overflow-y:auto;
+  padding:4px 10px calc(var(--bar-h) + var(--sab) + 6px)}
 .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}
+/* 紧随卡片的附注（「我的」的分组说明）：本来就小一号、灰一档，但 .history__hint 默认是
+   「整页居中 + 大上下留白」的空态样式，套在卡片下面会把版面撕开 ——
+   这里压成左对齐的一行小字，留白只留在卡片与附注之间。 */
+.history__hint--foot{padding:0 14px 4px;font-size:12px;line-height:1.5;text-align:left}
+.history__hint--foot b{color:var(--ink);font-weight:600}
+/* 附注的**左缘要对齐卡片的文字**（2026-10-26 截图量出来的 13px 错位）：
+   .history__list 左右各 10 内边距 → 卡片外缘在 10、边框 1 → 卡内 padding 12、行内 2
+   → 行文字左缘在 25。附注自身的 padding 14 + 这个 margin 就是 25。
+   两端写死只会让「附注」和「卡片里那一行」差半个字，眼一看就是没对齐。 */
+.mine .history__hint--foot{margin:0 5px}
+/* 我的 → 飞书推送：整页是「组标题 + 行 + 整行按钮 + 说明」的流，
+   行内的值列不该再占一半宽（「已配置 · 本机配置」这种会被省略号吃掉后半截）。 */
+#feishuBody .setrow{padding:12px 2px}
+#feishuBody .setrow__v{max-width:none;overflow:visible;text-overflow:clip}
+#feishuBody .btn{display:block;width:calc(100% - 40px);margin:6px auto;text-align:center}
 /* 会话列表加载失败（连不上桌面端）的失败态：不再是一行灰字，给图标 + 人话原因 +
    可复制地址 + 重试/编辑环境入口（2026-10-25：「失败时的界面显示要设计一下」）。
    颜色全走变量，暗/亮主题自动跟随；图标与排队/失败行同一套「一枚图标 + 状态 tint」。 */
@@ -422,6 +576,9 @@ textarea{font:inherit}
 .srow--stalled .srow__ico{background:var(--tint-wait);color:var(--warning)}
 .srow--stalled .srow__ico--queued::after{display:none}
 .srow--stalled .srow__s{color:var(--warning)}
+/* 「排队等跑」那行：副标题是整行唯一的文字说明，不能停在小号淡色上 —— 深色下 12px 的 --faint
+   压在墨绿底上发糊（2026-10-25 第二轮）。提到 --muted（raised 7.0 / canvas 9.4），与「运行中」同档。 */
+.srow__ico--queued~.srow__col .srow__s{color:var(--muted)}
 .srow__ico{flex:0 0 auto;width:44px;height:44px;border-radius:50%;background:var(--subtle);
   display:flex;align-items:center;justify-content:center;color:var(--ink);position:relative}
 /* 会话状态：用颜色区分（无角标、无描边） */
@@ -442,6 +599,27 @@ textarea{font:inherit}
    ⚠️ 只有**一种**等待样式：新任务排队、以及会话有追问在排队，用的都是它
    （2026-10-21 用户：「排队标志在会话左边的图标里设计 1 个等待样式即可」）。 */
 .srow__ico--queued{background:var(--tint-queued);color:var(--queued)}
+/* 自动模式判冲突的排队行：图标右下角一个「AI」小标（2026-10-26 用户：「AI判断的任务
+   需要串行排队的 显示 1 个特殊的标识」）。**不动**上面那套排队样式（紫色呼吸环是
+   「有一条在排队」的唯一视觉，2026-10-21 定的），只多一个「这是 AI 判的」的小标，
+   这样「没轮到」和「判了冲突」在列表上能一眼分开。 */
+/* 形状与置顶图钉**同款**（2026-10-26 用户：「ai 串行排队的跟置顶的一样使用角标标识」）：
+   18×18 圆、白底、1.5px 描边、右下角。只是颜色走排队紫、图标是四芒星（AI 判断），
+   所以「AI 在调度」与「我钉住的/在跑临时置顶」一眼能分开。 */
+.srow__ico-ai{position:absolute;right:-4px;bottom:-4px;z-index:1;width:18px;height:18px;border-radius:50%;
+  display:flex;align-items:center;justify-content:center;pointer-events:none;
+  background:var(--raised);color:var(--queued);border:1.5px solid var(--queued)}
+/* 运行中「临时置顶」标记：这类行被自动提到最前面（跑完归位），在**图标**上给一枚
+   小图钉角标（右下）。行尾不再画任何东西（2026-10 用户：行尾图钉无意义；
+   置顶状态只做在图标里）。与 AI 排队标共用右下角但互斥：那条只在 queued
+   出现，这条只在 run 出现，同一行不会两枚叠在一起。 */
+.srow__ico-pin{position:absolute;right:-4px;bottom:-4px;z-index:1;width:18px;height:18px;border-radius:50%;
+  display:flex;align-items:center;justify-content:center;pointer-events:none;
+  background:var(--raised);color:var(--primary-action);border:1.5px solid var(--primary-action)}
+/* 手动置顶（manual）= 实底；自动临时置顶（auto）= 白底描边。一眼分得出
+   「我钉住的」和「因为在跑临时提上来的」。 */
+.srow__ico-pin.is-manual{background:var(--primary-action);color:var(--on-primary-action);
+  border-color:var(--primary-action)}
 .srow__ico--queued::after{content:"";position:absolute;inset:-2px;border-radius:50%;pointer-events:none;
   border:2px solid var(--queued);animation:srow-breathe 2.2s ease-in-out infinite}
 @keyframes srow-breathe{
@@ -464,7 +642,6 @@ textarea{font:inherit}
 .srow__time{flex:0 0 auto;font-size:12px;color:var(--muted)}
 /* 运行中**自动临时置顶**的小图钉（2026-10-22）：让「它凭什么在最上面」有据可查。
    手动置顶靠「置顶」分段表达，不重复画；跑完 statusOf 不再是 run，图钉随之消失。 */
-.srow__auto{flex:0 0 auto;display:flex;align-items:center;color:var(--primary-action);opacity:.75}
 /* 子会话（团队模式拆出的子任务，2026-10-22）：**缩进挂在主会话下面**，不占顶层一行。
    左侧用**树形折线**（├─ / └─）接出来，不是一根通到底的竖线（2026-10-24 用户：
    「团队模式的子会话的线设计成树状 不要一条竖线」）—— 多个子任务读起来是一棵树，
@@ -494,6 +671,10 @@ textarea{font:inherit}
 .srow--sub{padding:9px 8px 9px 4px;gap:10px}
 .srow--sub .srow__ico{width:32px;height:32px}
 .srow--sub .srow__ico svg{width:16px;height:16px}
+/* 子会话图标只有 32px：角标跟着缩一档，别盖住图标本身。 */
+.srow--sub .srow__ico-pin,.srow--sub .srow__ico-ai{width:15px;height:15px}
+.srow--sub .srow__ico-ai svg{width:9px;height:9px}
+.srow--sub .srow__ico-pin svg{width:10px;height:10px}
 .srow--sub .srow__t{font-size:14px;font-weight:500}
 .srow--sub .srow__s,.srow--sub .srow__time{font-size:11px}
 /* 团队会话的标志（2026-10-21）：core 在 /desk/sessions 里给 mode:"team"。
@@ -541,9 +722,11 @@ textarea{font:inherit}
 .wsrow__open{flex:1;display:flex;align-items:center;gap:12px;min-width:0;padding:10px 8px;border-radius:14px;text-align:left}
 .wsrow__open:active{background:var(--subtle)}
 .wsrow__l{flex:1;min-width:0;font-size:15px;color:var(--ink);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-/* 串行等待中的任务数：空间组折叠时也要看得见（颜色与「等待中」行一致） */
+/* 串行等待中的任务数：空间组折叠时也要看得见（颜色与「等待中」行一致）。
+   主色走 --badge-accent（默认 = 排队金）：需求页把「待整理」也复用这枚徽标时改挂警告琥珀，
+   11px 的字在墨绿底上要 ≥4.5，金色 7.5 / 琥珀 5.8 都够（2026-10-25 第二轮）。 */
 .wsrow__badge{flex:0 0 auto;padding:1px 7px;border-radius:var(--r-full);font-size:11px;line-height:16px;
-  color:var(--queued);background:var(--tint-queued);white-space:nowrap}
+  color:var(--badge-accent,var(--queued));background:var(--tint-queued);white-space:nowrap}
 .wsrow__chev{color:var(--muted);display:inline-flex;transition:transform .15s}
 .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)}
@@ -593,7 +776,7 @@ textarea{font:inherit}
   font-size:15px;font-weight:500;color:var(--primary-action);text-align:left}
 .envmenu__add:active{background:var(--subtle)}
 /* toast（没有通知能力时的兜底提示） */
-.toast{position:fixed;left:50%;bottom:calc(92px + env(safe-area-inset-bottom));transform:translateX(-50%);
+.toast{position:fixed;left:50%;bottom:calc(var(--bar-h) + var(--sab) + 2px);transform:translateX(-50%);
   max-width:82vw;padding:10px 14px;border-radius:12px;background:var(--raised);color:var(--ink);
   border:1px solid var(--border);font-size:13px;text-align:center;z-index:1300;
   box-shadow:0 12px 30px -12px var(--app-shadow)}
@@ -645,7 +828,11 @@ button.setrow{font-family:inherit}
 .setcard{background:var(--raised);border:1px solid var(--border);border-radius:16px;margin:10px 6px;padding:0 12px}
 .setrow{display:flex;align-items:center;gap:12px;width:100%;padding:14px 2px;text-align:left}
 .setrow+.setrow{border-top:1px solid var(--border)}
-.setrow__l{flex:1;min-width:0;font-size:15px;color:var(--ink)}
+/* 配置项标题：**永不换行**（2026-10-26 用户：「配置的标题要保证不换行 引擎和模型可换行显示」）。
+   原来是 flex:1 铺满，右值变宽（引擎 · 模型同一行）时标题被挤成「默认引 / 擎」两行。
+   现在标题按自然宽度排、不换行（真放不下才省略），剩下的空间交给右值；可换行的是**值**不是标题。 */
+.setrow__l{flex:0 1 auto;min-width:0;margin-right:auto;font-size:15px;color:var(--ink);
+  white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
 .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 用户：「没显示出来」），所以这里允许换行、两行各自省略。 */
@@ -654,10 +841,43 @@ button.setrow{font-family:inherit}
 .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-26 用户：「引擎和模型显示在同一行即可」）：
+   右格 = 主行「引擎 · 模型」，备用小字跟在后面。原来模型独占一行，合成一行后右格变宽，
+   单行省略会把模型名整个吃掉 —— 改成「放得下就一行，放不下折到第二行」，不截断。 */
+.setrow--engmodel .setrow__v--pair{flex:1 1 auto;min-width:0;max-width:none;align-items:flex-end}
+/* 引擎行：标题不收缩（给「默认引擎 / 建议引擎」留足），引擎+模型那格吃剩余宽度并允许换行。 */
+.setrow--engmodel .setrow__l{flex:0 0 auto}
+.setrow--engmodel .setrow__pair-main{white-space:normal;overflow-wrap:anywhere;text-align:right;
+  line-height:1.35}
+/* 同一格里两个值：引擎用正文色、模型用次级色，中间加个淡分隔点，免得读成一个长名字。 */
+.setrow--engmodel .setrow__pair-main .engmodel__mid{color:var(--faint);padding:0 3px}
+.setrow--engmodel .setrow__pair-main .engmodel__model{color:var(--ink-soft)}
+/* 内嵌的模型 span 只给测试 / 播报留 id（#defaultModel / #suggestModel），不单独占位。 */
+.setrow__v--model{display:none}
 /* 有新版本时这一格变成可点的「升级」提示（2026-10-22 用户：「版本现在也没点击升级的地方」） */
 .setrow__v.is-upgradable{color:var(--primary-action);font-weight:600}
 .setrow--danger{color:var(--error-text)}
 .setrow--danger .setrow__l,.setrow--danger .setrow__v{color:var(--error-text)}
+/* 「我的」：分组名**放进卡片里**当标题（2026-10-26 用户：「分类和下面的配置融合感太差」）。
+   原来是「卡外小标签 + 独立圆角卡」，两者之间 6px 的空隙把它读成两块各自的东西；
+   现在组名是卡内第一行，与下面的设置行同属一个圆角容器，中间只隔一段内边距。
+   ⚠️ 只限 .mine：发现页 / 插件页的 `.history__group` 仍是卡外分组名，别一起改。 */
+.mine .setcard{padding-top:2px}
+.mine .history__group{padding:12px 2px 8px;font-size:12px;font-weight:700;color:var(--muted);
+  border-bottom:1px solid var(--border)}
+/* 夹在行之间的包裹层（#teamCard）：要让被包裹的 `.setrow` 与其它行读起来完全一样 ——
+   分隔线画在包裹层上，行自己不带线；否则 `行 + 行` 的相邻选择器跨不过这层，线会断。 */
+.mine .mslot{border-top:1px solid var(--border)}
+.mine .mslot>.setrow{border-top:0}
+.mine .mslot[hidden]{display:none}
+/* 组名后面那一行不带顶线（`.setrow + .setrow` 只给行与行之间画线），
+   分隔线只在同组内出现 —— 组名到第一行是「标题 → 内容」，不该有线。 */
+.mine .setcard>.history__group+.setrow,
+.mine .setcard>.history__group+.setrow--split{border-top:0}
+/* 行尾小动作（「当前桌面 [切换]」）：文字按钮，落在值后面，不抢主行的读取顺序。
+   用 --primary-action 而不是新造色 —— 全 App 的可点文字只有这一种颜色。 */
+.setrow__act{flex:0 0 auto;margin-left:6px;padding:2px 8px;border-radius:var(--r-full);
+  font-size:13px;color:var(--primary-action);background:var(--subtle);font-family:inherit}
 /* 环境编辑（我的 → 环境）：名称 / 地址 / 令牌三栏。
    环境不能只靠扫码「连过才记得」—— 用户要显式配置 IP 和名字（2026-10-22）。 */
 .envfield{display:block;width:100%;height:44px;margin-top:6px;padding:0 12px;border-radius:10px;
@@ -713,44 +933,117 @@ button.setrow{font-family:inherit}
      · 会话页由 composer 的下内边距负责，见下面的 `#conv .composer`
      · 启动页不显示底栏（showLauncher 里 hidden），无需留白
 
-   min-height 而不是 height：底栏还要吞 safe-area（34px），
-   border-box 下固定 height 会让内部 tab 被压到 26px 高。
-   **56 必须写成 `56 + safe-area`**（2026-10-22 实机：「手机上现在 tab 上下没间距」）：
-   `*{box-sizing:border-box}` 下 min-height 含 padding，56 里先被 safe-area 吃掉 34，
-   内容只剩 22 —— 44×34 的选中浅底直接顶到了栏的上下边。桌面上 env()=0 看不出这个问题。
-   **56**（「底栏只保留图标不需要文字了」）：去掉标签后只剩 25px 图标 + 44×34 浅底，
-   56 给到浅底上下各 11px，栏体也矮下来。 */
+   **高度固定**（2026-10-25 用户：「弧线压在图标上了 底栏高度要固定」；
+     2026-10-26 用户：「底栏高度固定 图标距离底部的距离固定 弧线距离底部的距离也固定」）：
+     · `height`（不是 min-height）+ 边框盒：栏体恒为 **--bar-h + safe**，不随内容长高。
+     · `padding-bottom` = safe-area 只把栏体往上抬，图标只在上面 --bar-h 的内容区里排布。
+       图标**不再居中**：居中会让距栏底的距离随图标自身高度变（26px 的离底 15、28px 的离底 14，
+       四枚不在一条基线上），也和 --ic-gap 这个显式常量冲突。改成 `align-items:flex-end`
+       + `padding-bottom:var(--ic-gap)`（见 .tab）—— 距栏底恒为 --ic-gap，与图标尺寸无关。
+   弧线是**上缘**、不是栏外的装饰：最深处距栏底 --arc-dip（45.5），所以栏顶 56 − 45.5 = 10.5
+   是那条弧的沉深，端点仍落在栏顶（y=0）。三个数都是常量，互不推算。 */
 .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));
-  /* ⚠️ 必须是**不透明**的栏面：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)}
+  box-sizing:border-box;
+  /* ⚠️ `var(--sab)` 不是 `env(...)`：键盘弹起时 env 会归零，栏体就会矮掉一整条安全区
+     （根因见 :root 里 `--sab` 那段注释）。这一条是「两种状态高度一致」的唯一开关。 */
+  height:calc(var(--bar-h) + var(--sab));
+  /* ⚠️ 栏体**不画底色**（2026-10-25 用户：「底色只应该弧线以下才有」）：
+     底色由子层 .bararc 按弧线裁剪着画 —— 弧以上露出页面。曾经在这里写 `background:var(--raised)`，
+     等于在整条矩形栏上又铺一层玉面，弧线上方就多出一块比页面亮的矩形（手机截图里弧上那层「绿板」）。
+     不透明这一点仍由 .bararc 的玉面 + FAB 井（.tabbar::before，自带不透明底）保证；
+     不用半透 + blur：滚动时下面那行「magic-stock · codebuddy」会透上来压在图标上（2026-10-25 实测）。 */
+  background:transparent;
+  /* 栏体**不画**自己的上边线（2026-10-25 用户：「也不存在横线 自然过渡的弧线」）：
+     原来的 `0 -1px 0 var(--border)` 会在弧面落点之间从一头拉到另一头，
+     把「弧面 → 栏身」那道台阶读成一条贯穿的横线。栏沿交给下面的 .bararc 按同一张弧线画。 */
+  padding-bottom:var(--sab)}
+/* 上缘 = 一条**整幅的、向上凹的弧**（2026-10-25 用户：「底栏弧度要反过来向上 也不存在横线
+   自然过渡的弧线 左右向上翘」）：
+   两头翘、中间沉 —— 屏底像一片托起来的弧面。上一版是两块「飞檐」+ 中段一条直的栏边，
+   于是弧与弧之间横着一道线、弧的落点又和栏边拼出台阶；这一版**不再有任何直线与直角**：
+   **整幅上缘就是这一条弧**，弧以下全是栏的面，弧以上全是页面。
+
+   ① 形状：`.bararc` 是一整块**背景层**，铺满底栏的整个盒子（inset:0），z-index:0 垫在五个 tab 下面。
+      这一层里画「弧线以下的玉面」+「弧线本身」两根描边，所以弧以上露出来的是页面。
+      ⚠️ 不要改回「贴在栏顶上方的一条带」（bottom:100%）：那样会同时踩两个老坑 ——
+      (a) 底栏是 z-index 的整层，弧要压住底栏自己的背景，就必须给底栏开 filter 强制开层，
+          而开层之后 SVG 按整数倍设备像素重画，暗色下弧沿会渗出一排阶梯和发丝竖纹；
+      (b) 弧与栏身分成两层画，拼接处要再补 1px 的缝。背景层这里两个坑都不存在。
+    ② 弧（一条整幅宽的三次贝塞尔，两块对称的浅盆合起来）：
+      端点放在 y=0（两端上翘到顶），两个控制点都放在 y=AMP：
+        M0 0 C x1 AMP, x2 AMP, W 0        x1 = W·K_END，x2 = W − x1
+      AMP = 14：屏幕上中间比两端低约 10.5px（曲线最深点到控制点高度的 3/4）。
+      历经的调整（2026-10-25）：先压到 8 → 用户「要再弯一些」抬到 14 → 又改成拱桥形被否（「左高右低」）→
+      翻成现在这个嘴角形。K_END = 30%：两端一进屏就以约 30° 起翘，往中间连续过渡，没有平台段。
+      ⚠️ AMP 与 K_END 是两个旋钮：AMP 决定「中心比两端低多少」，K_END 决定「两端翘得多急」。
+      K_END 太小（如 8%）两端会陡、中段接近一条平线（读作「平线 + 两头小翘」）；太大则中段发鼓。
+      SVG 里 y 轴向下，所以**端点 y=0、控制点 y=AMP** 才是「中间低、两端高」的嘴角形；
+      反过来写就是拱桥形（左右虽然对称，但看着像「左高右低」）。改这里之前先看宿主脚本里的同段注释。
+      写法上不用 viewBox + preserveAspectRatio="none"：拉伸会让描边宽度随屏宽变形
+      （窄屏约 0.6px、平板近 2px）。所以 JS 按栏的实测像素生成路径，**1 个用户单位 = 1px**，描边恒定 2px。
+    ③ 取色：玉面是 `--bar-fill`（默认 = --raised）。深色主题给**比栏面暗一档、比页面亮一档**的
+      玉面，暗底上才读得出「栏浮在页面之上」；浅色不给，白栏面 + 灰弧线本身就是清晰的边界。
+      浮起感完全靠「页面 → 弧线 → 玉面」这一道明度阶梯，不投任何投影 ——
+      filter 一有位移/模糊，暗色下弧沿就出竖纹、台阶（见上面的老坑说明），代价比收益大。
+    ④ pointer-events:none 不吃点击；FAB 槽（.tabbar::before，z-index:1）画在这层之上，互不越界。 */
+/* ⚠️ 背景层必须挂在底栏的**子元素**（div）里画，不能直接给 `.tabbar` 加背景，也不能用伪元素：
+   ① `.tabbar` 自己的 `background` 会垫在 `.tabbar::before`（FAB 井，z-index:1）下面 —— 那没问题；
+      但井是圆的，栏的直角背景会在井的圆角外露出一圈直角（浅色下读成「按钮垫了个盘子」）。
+   ② 所以弧面 + 玉面放在子元素里，它的 z-index:0 与 `::before` 的 z-index:1 同处底栏的层叠上下文，
+      谁来压谁由 z-index 决定，井永远画在玉面之上 —— 亲眼踩过的回归：早先把弧层做成 SVG 根元素时，
+      右半屏的 tab 会被整块遮住（2026-10-25 无头实测）。所以 `.tab` 自己也带 position+z-index:2，
+   ③ SVG 是替换元素：`left:0;right:0` 对它算不出宽度，会落到默认 300×150 再等比缩进
+      （2026-10-25 无头实测，弧面只铺到三分之二屏）。所以这里改成**原生尺寸 = 几何尺寸**：
+      外层 div 四边铺满栏盒子，SVG 不给 width/height/preserveAspectRatio，只由脚本把
+      viewBox 和 `width/height` 属性都设成栏的实测像素（1 个用户单位 = 1px）。
+      ⚠️ 不要退回「preserveAspectRatio="none" + 100% 尺寸」那种拉伸写法：无头 Chromium 2× DPR 下，
+      拉伸后的 SVG 会把下缘抗锯齿按「像素块」重采样成 82px 宽的竖条（2026-10-25 掩膜实测）。
+   ⚠️ 不要给这一层加 `transform:translateZ(0)` / `will-change`：另开合成层后暗色下弧沿出竖纹。 */
+/* ⚠️ 只盖到栏底**之上**（bottom = safe-area），别让四边都铺满栏盒：
+   否则弧线以下那整块玉面会一直画进安全区，屏幕最底下留出一条比页面亮的白带
+   （2026-10-25 无头实测：栏高 56 + safe 34，底下 34px 是白的）。栏体只占 56，玉面也只该到 56。 */
+/* ⚠️ 这一层**铺满整个栏盒**（bottom:0，含安全区）—— 2026-10-26 改，原先是 `bottom:var(--sab)`。
+   那版让玉面只铺到内容区（56），底下 34px 露出页面底色。浅色下页面 #F8FAFC 与栏面 #FFFFFF
+   只差 3 个色阶，几乎看不出；深色下页面 #06180F 与栏面 #152E1F 差一大截，屏幕最底就是一条
+   **黑带**（2026-10-26 深色截图实测）。而且用户给的实机截图里栏面是**一直铺到屏幕底**的。
+   铺满之后栅面上方多出来的那 34px 由弧线自己切掉（`--bar-h` 决定的透明区，见脚本），
+   所以「页面 → 弧线 → 玉面到底」这条阅读顺序不变，只是底部不再有接缝。 */
+.bararc{position:absolute;top:0;left:0;right:0;bottom:0;z-index:0;pointer-events:none;
+  /* ⚠️ 这一层 filter 是逼合成层用的（值本身是恒等变换，不画任何东西）。无头 Chromium 2× DPR
+     实测：不开层时，下缘抗锯齿的片段会和底栏背景一起被拆成一排 82px 宽的竖条
+     （= 五个 tab 区的背面，深浅两主题都出现；2026-10-25 掩膜实测）。开层后这层按设备像素
+     整层重画，竖条消失。⚠️ 值里**不能有位移或模糊**（别写成投影）：重采样会把台阶和发丝纹渗回来。
+     ⚠️ 也别换成 transform:translateZ(0) / will-change：那会换一种光栅化路径，暗色下弧沿又出竖纹。 */
+  filter:drop-shadow(0 0 0 transparent)}
+.bararc__svg{display:block;width:100%;height:100%;fill:var(--bar-fill,var(--raised))}
+.bararc__d{fill:var(--bar-fill,var(--raised))}
+/* 弧边：三套主题各自给 --bar-edge（浅色 #CBD5E1 灰、深色 rgba(110,231,168,.28) 玉光）。
+   ⚠️ 不要再让它回落到 --border：深色 --border 是 .18 的低透明绿，压在玉面上几乎消失；
+   而浅色那档 #CBD5E1 漏进深色又会变成刺眼白线（2026-10-26 两种都实测过）。
+   每个主题块都要显式写一次 --bar-edge（见 :root / media:light / html[data-theme=dark]）。 */
+.bararc__s{fill:none;stroke:var(--bar-edge,var(--border));stroke-width:2px}
 /* 只有图标：文案从底栏拿掉（2026-10-22 用户），语义交给 aria-label，不靠视觉标签。
    命中区仍是 flex:1 × 56，比"图标 + 文字"那版更高更宽，点起来更稳。 */
-.tab{flex:1;display:flex;align-items:center;justify-content:center;
+/* ⚠️ 图标**底边对齐**（`align-items:flex-end`），不再垂直居中。
+   居中会让「距栏底的距离」随图标自身高度变：26px 的器物离底 15、28px 的「我的」离底 14
+   （2026-10-26 无头实测 gapSvgToBarBottom 15/15/15/14）—— 用户要的是「图标距离底部的距离固定」，
+   四枚必须落在同一条基线上，而且这个距离要能单独调。
+   现在距离由 `--ic-gap` 单点控制：`.icw` 的 `margin-bottom` 吃它，与图标尺寸、栏高都无关。
+   ⚠️ 不要退回垂直居中 + 固定内边距的写法：那样「我的」那枚 28px 会比别的高 2px 顶到弧线更近。 */
+.tab{flex:1;display:flex;align-items:flex-end;justify-content:center;
+  /* ⚠️ 这里**不能扣 safe-area**（2026-10-26 修）。
+     旧写法是 `calc(var(--sab) + 13px)`，那是 `min-height` 时代的补丁：当时栏体被
+     padding 撑到 56 + 34，tab 也长到 90，图标在 90 里居中会往下掉 17，所以扣「sab」把它拽回来。
+     但栏体现在是**定高 `--bar-h + sab` 且自带 `padding-bottom:sab`** —— 内容区永远只有 --bar-h，
+     tab 的高度也是 --bar-h。再扣一遍 sab 就是**重复扣减**：图标被挤到栏顶之上 12.5px
+     （实测 icw.top=654.5 而栏顶 667），弧线正好横穿图标，也就是用户看到的「弧线压在图标上」。
+     现在位移只由 `--ic-gap` 决定，弧线位置只由 `--arc-dip` 决定，两者互不推算。 */
+  /* ⚠️ 必须自成一层并压过 .bararc：弧面是整块背景层，若和 tab 同层，「弧线以上露页面」
+     的透明部分盖在 tab 上是靠设备坐标对位画的，无头 Chromium 2× DPR 下对不上，
+     右半屏图标被整块抹掉（2026-10-25 实测）。position+z-index 让每个 tab 单独一层，
+     叠放顺序只由 z-index 决定，与弧层怎么画无关。 */
+  position:relative;z-index:2;
   /* 未选中用 --tab-off 而不是 --muted：--muted 是「次要文字」的档位，
      拿来画 25px 的器物剪影偏淡 —— 浅色下在白栏面上只有 5.1:1，
      而剪影全靠实心面积撑辨识度，实测比正文更吃对比（正文有字重兜底，剪影没有）。
@@ -771,11 +1064,21 @@ html:not([data-theme="dark"]) .tab.is-on svg{
 @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(--tab-on-bg)}
+/* 选中态**只换图标颜色 + 一圈灵光，不铺底、不描边**（2026-10-26 用户：
+   「tab 图标选中时不需要背景色和边框」）。原来还有一块 44×34 的圆角底 + 1px 内描边，
+   理由是「没有文字之后颜色是唯一线索，得补个形状」；实机看下来那两块方形色块在
+   弧面玉青上像贴了补丁（四枚并排时尤其明显），而且浅色主题下 10% 的玉青本来就几乎看不见。
+   语义现在完全由「玉青 + 灵光」承担 —— 未选中是墨绿/深灰的实心剪影，选中是同形状的玉青发光，
+   明度 + 色相 + 光晕三个通道同时变，不靠色块的形状也读得出。
+   ⚠️ `--tab-on-bg` 令牌仍留在主题表里（别的皮肤 / 后续方案可能要用），但**底栏不再消费它**。 */
+/* ⚠️ `.icw` 的**高度必须是 auto**（2026-10-26 改）：原来写死 34，SVG 在里面居中，
+   26px 的图标上下各留 4px —— 于是 `margin-bottom:--ic-gap` 只能把「盒子底」放到 15px，
+   真实图标底还差 4px；而 28px 那枚只差 3px，四枚又错开了。高度交给内容撑，
+   盒底 = 图标底，`--ic-gap` 就是图标到栏底的**真实**距离，与图标尺寸无关。
+   ⚠️ 那个 44×34 的尺寸原本是给选中底（已删，见上面的注释）用的，现在只剩宽度还有意义
+   （让四枚的点击/对齐中心一致）；高度留着反而制造上面那个 4px 的暗坑。 */
+.tab .icw{display:grid;place-items:center;width:44px;height:auto;border-radius:11px;
+  margin-bottom:var(--ic-gap)}
 .tab svg{display:block;transition:transform .16s}
 .tab:active svg{transform:scale(.92)}
 /* ── 「快速新建」：**半嵌入**底栏的圆形主按钮（2026-10-22 定稿）
@@ -805,8 +1108,10 @@ html:not([data-theme="dark"]) .tab.is-on svg{
    几何全用相对量（`bottom:calc(100% - 44px)`、`top:-27px`），安全区变化时洞和按钮一起走。
 
    **两页一致**：会话页不再把「＋」收进栏内（2026-10-22 用户：「圆没有突出了 …两个效果要一致」）。
-   凸出的圆在列表页和对话页长得完全一样，只用 composer 的下内边距给它让出空间。 */
-.tabfab{flex:0 0 84px}
+   凸出的圆在列表页和对话页长得完全一样，只用 composer 的下内边距给它让出空间。
+   ⚠️ `.tab` / `.tabfab` 都要 `padding-bottom:env(safe-area-inset-bottom)`：底栏高度是 `56 + safe-area`，
+      不扣的话图标会在整条栏里居中、掉进安全区（2026-10-25 用户：「我的 tab 下面还没好」）。 */
+.tabfab{flex:0 0 84px;padding-bottom:0}  /* 与 .tab 同一口径：栏体已扣过一次 safe-area，这里不再扣 */
 /* 洞 = 半圆 + 接触影。
    槽底是 `--fab-well`（栏面稍暗一档的**同色系**），不是 `--canvas`：
    用页面底色在暗色下会成黑箍，在浅色下又几乎看不见 —— 两头都不对。
@@ -816,18 +1121,58 @@ html:not([data-theme="dark"]) .tab.is-on svg{
    **露出的槽宽只有 3px**（槽半径 37 − 按钮半径 34）。曾经用更大：那圈灰色槽底读作「按钮下面垫了个盘子」，
    正是用户否掉的形态。3px 只够出一条接触缝 —— 看得见槽、看不清槽底，就等于"切出来的"。 */
 .tabbar::before{content:"";position:absolute;z-index:1;pointer-events:none;
-  left:50%;top:-27px;transform:translateX(-50%);
+  left:50%;
+  /* 与按钮**同心**：按钮圆心距内容区底 `--fab-gap + 34`，所以井的圆心也在这里，
+     井顶 = 内容区顶 − (圆心离顶) − 井半径(37)。以前写死 `top:-27px`（= 56 − 46 − 37），
+     改栏高或改 --fab-gap 就会和按钮分开 —— 现在跟按钮一起走。 */
+  top:calc(var(--bar-h) - (var(--fab-gap) + 34px) - 37px);
+  transform:translateX(-50%);
   width:74px;height:74px;border-radius:50%;
-  clip-path:inset(27px 0 0 0);          /* 圆心在栏顶下方 10px：切掉露在外面的那一截，只留栏内的弧 */
+  /* ⚠️ 只留**上半圈**，下缘正好压在弧线上（2026-10-26 用户：「圆的灰色光圈应该有上半圈跟弧线形成连接」）。
+     曾经写的是 `inset(27px 0 0 0)`（切顶留底），露出 y=27~74 这 47px —— 其中 y=37.5~74
+     那 36.5px 整个落在**弧线以下**，于是按钮腰线以下兜出一道完整的下半圈灰带，
+     弧线以上只剩零头 10.5px，读作「按钮垫了个孤立的浅灰盘子」（用户截图确认的形态）。
+     现在反过来：切掉底部，只保留 y=0~37.5 的上半圈，它的**下缘就落在弧线最深处那条线上**，
+     于是灰环从弧线处起兜住按钮上半圈 —— 环与弧线是同一条边界，接成一体而不是两截。
+     裁剪线位置 = 井内弧线 y = (--fab-gap + 34 + 37) − --arc-dip（= 12+34+37−45.5 = 37.5，
+     与井内圆心 37 只差 0.5，即弧线基本穿过圆心）；要切的底部 = 井高 74 − 该值 = 36.5。
+     ⚠️ 弧线是弯的（两端高、中间低），这里用水平线裁，两端各差 0.34px（弧线在 x=±37 处 y=10.16 对 10.5），
+        肉眼不可见，但**别把 --arc-dip 调得比 --fab-gap + 34 还小**，否则裁剪线会跑到井底下面去。 */
+  clip-path:inset(0 0 calc(74px - (var(--fab-gap) + 34px + 37px - var(--arc-dip))) 0);
+  /* ⚠️ 井的底必须是不透明的（var(--fab-well) 本身是实色）：栏体已经透明，
+     底色只在弧线以下，井露出的那一圈只能靠它自己兜住，否则会露出背后的页面/滚动内容。
+     这里**只画接触影，不画外圈的线**（线交给下面的 ::after 描边，见那里的注释）。 */
   background:
     radial-gradient(circle 37px at 50% 50%,
       var(--fab-notch) 33.5px,
       var(--fab-notch) 34.5px,
-      color-mix(in srgb,var(--fab-notch) 35%,transparent) 36px,
-      transparent 37px),
+      color-mix(in srgb,var(--fab-notch) 35%,transparent) 35px,
+      transparent 35.5px),
     var(--fab-well)}
+/* 井的外圈线：**必须是一条真正的描边圆**，不能用径向渐变的末圈（2026-10-26 用户：
+   「弧线要与外圈的线样式一致才有连贯感」）。
+   ⚠️ 为什么不能用渐变：径向渐变的「环」在数学上是一个圆环带（半径 35→37），
+      它在**水平剖面**上的厚度随高度剧烈变化 —— 圆心处 2.00px、y=20 处 2.41、
+      y=30 处 3.63、y=36 处 8.54。而被 clip-path 切出来的井正好是上半圈，
+      弧线接入的位置（井的 9 点/3 点，y≈37）恰好在圆环最宽的地方：实测那一竖条暗色
+      从 y=183.75 一直连到 y=193（9.3px 厚），旁边纯弧线只有 2px（y=190→191.7）。
+      于是「线」变成「带」，与弧线完全不是一个东西。
+   `border` 的宽度是**恒定**的（沿法线 2px），所以这样画出来的圈任何角度都是 2px，
+   与 `.bararc__s` 的 `stroke-width:2px` 完全同宽、同色（同一个 `--bar-edge` 令牌）。
+   ⚠️ 用 inset:0 + border 而不是缩小尺寸：宽度 74 = 井的直径，border 2 后内容盒正好 70，
+      `box-sizing:border-box` 保证外径仍是 74，与井严丝合缝。
+   ⚠️ 同样要跟着切底：否则下半圈又冒出来（用户上一轮刚否掉的形态）。 */
+.tabbar::after{content:"";position:absolute;z-index:1;pointer-events:none;
+  left:50%;top:calc(var(--bar-h) - (var(--fab-gap) + 34px) - 37px);
+  transform:translateX(-50%);
+  box-sizing:border-box;width:74px;height:74px;border-radius:50%;
+  border:2px solid var(--bar-edge);
+  clip-path:inset(0 0 calc(74px - (var(--fab-gap) + 34px + 37px - var(--arc-dip))) 0)}
 .tabfab__b{position:absolute;z-index:2;
-  left:50%;bottom:calc(100% - 44px);              /* 上露 24 / 下沉 44，距栏底 12 */
+  /* ⚠️ 从**栏底**量，不用 `100% - 44px`（那是拿整条栏高反推的：栏高一变，按钮就跟着漂）。
+     `bottom` 的基准是绝对定位包含块的 **padding box 底边** = 栏盒底边（含安全区），
+     而「距底部固定」指的是距**栏面底边**（= 内容区底 = 栏底 − 安全区），所以要先跨过 --sab。 */
+  left:50%;bottom:calc(var(--sab) + var(--fab-gap));
   transform:translateX(-50%);
   width:68px;height:68px;
   display:flex;align-items:center;justify-content:center;
@@ -1026,9 +1371,11 @@ html[data-theme="dark"] .tabfab__b{
    「上露 24 + 呼吸 12 + 栏高 56」—— 输入框落在凸出圆弧上方 12px，不遮不压。
    原来 composer 下留 60（= 上探 30 + 呼吸 30）再叠占位的 68 栏，屏幕底到输入框 162；
    现在 56 + 24 + 12 = 92，对话区多出 70px。
-   56 必须与 .tabbar 的 min-height 对齐、24 必须与 .tabfab__b 的下沉量对齐（改一处要一起改）。
+   ⚠️ 2026-10-26：`56px` 换成 `var(--bar-h)`，「24」换成「--bar-h − --fab-gap − 34」的实算值。
+      三个常量改一个，这里的留白自动跟着走（以前写死 56 和 24，改栏高就会压住输入框）。
+      「上露」= 按钮顶到栏顶的距离 = --bar-h − (--fab-gap + 34)（按钮高 68，底距 --fab-gap）。
    **只叠一次**：safe-area 由这里一次性算进来，别再给 .composer 的基础 padding 加一遍。 */
-#conv .composer{padding-bottom:calc(12px + 24px + 56px + env(safe-area-inset-bottom))}
+#conv .composer{padding-bottom:calc(12px + var(--bar-h) - var(--fab-gap) - 34px + var(--bar-h) + var(--sab))}
 
 /* 组件挂载点：占满剩余高度 */
 #conv{flex:1;min-height:0;display:flex}
@@ -1105,6 +1452,23 @@ html[data-theme="dark"] .tabfab__b{
 .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}
+/* 横屏提示条：叠在页面顶部，一条就够（见 brSetLandscape）。
+   工作台按桌面宽屏排版（magic-video 三栏、magic-shorts 双栏），手机竖屏里右半边
+   直接被切掉，人看到的就是「打不开」。检测到溢出就自动转横屏，并用这条说明现状 +
+   给一条退路 —— 自动改变屏幕方向却不解释，比不改变更让人慌。 */
+.browser__land{position:absolute;z-index:3;left:50%;top:10px;transform:translateX(-50%);
+  display:flex;align-items:center;gap:8px;max-width:calc(100% - 24px);
+  padding:7px 8px 7px 12px;border-radius:999px;
+  background:var(--raised);color:var(--ink);font-size:12px;line-height:1.2;
+  box-shadow:0 4px 14px rgba(15,23,42,.16),inset 0 0 0 1px var(--border)}
+.browser__land[hidden]{display:none}
+.browser__land span{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+/* 横屏时挪到角落：居中的话正好压在旋转后正中间的内容上（实测最挡事的是分章表格）。 */
+.browser.is-land .browser__land{left:10px;top:10px;transform:none;max-width:calc(100% - 20px)}
+.browser__land b{font-weight:600}
+.browser__landbtn{flex:0 0 auto;border:none;border-radius:999px;padding:5px 10px;
+  background:var(--subtle);color:var(--primary-action);font-size:12px;font-weight:600}
+.browser__landbtn:active{opacity:.6}
 .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);
@@ -1291,7 +1655,10 @@ html[data-theme="dark"] .tabfab__b{
   <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-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>
+  <!-- 置顶 = 图钉，**正立**（用户 2026-10：「显示的钉子是直的」）。
+       形状按 Material push_pin 的比例加粗：宽帽 + 柱身 + 底翼 + 粗针，
+       小尺寸（12px 角标）也认得出是钉子，不是书签 / 十字。 -->
+  <symbol id="i-pin" viewBox="0 0 24 24" fill="currentColor"><path d="M17.6 9.2V4.8h1a1.2 1.2 0 0 0 0-2.4H5.4a1.2 1.2 0 0 0 0 2.4h1v4.4c0 2-1.5 3.6-3.4 3.6v2.7h7.3v6.6a1.7 1.7 0 0 0 3.4 0v-6.6h7.3v-2.7c-1.9 0-3.4-1.6-3.4-3.6z"/></symbol>
   <symbol id="i-folder" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7a2 2 0 0 1 2-2h3.2l1.6 2H18a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2z"/></symbol>
   <symbol id="i-chev-r" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m9 5 7 7-7 7"/></symbol>
   <symbol id="i-chev-d" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m6 9 6 6 6-6"/></symbol>
@@ -1390,14 +1757,14 @@ html[data-theme="dark"] .tabfab__b{
              填金在选中绿上只有 1.29，填孔在 28px 下糊成一团黑；
              细线两头都不犯：暗底当亮线、亮底当暗线，且不占体积。
              金丹垫 canvas 暗衬后才立得住（朱 vs 绿 2.0 → 朱 vs 暗衬 4.0）。 -->
-                  <g fill="none" stroke="var(--canvas,#0B1512)" stroke-width=".62" stroke-linecap="round">
+                  <g fill="none" stroke="var(--canvas,#06180F)" 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 cx="12" cy="16.15" r=".78" fill="var(--canvas,#06180F)" stroke="none"/>
                   <circle class="yypill" cx="12" cy="16.15" r=".5" fill="var(--q-blood,#E23B2E)" stroke="none"/>
                 </g>
       </svg></button>
@@ -1416,7 +1783,11 @@ html[data-theme="dark"] .tabfab__b{
   <div class="history__list" id="historyList"></div>
 </div>
 
-<!-- ══════════ 我的（设置）══════════ -->
+<!-- ══════════ 我的（设置）══════════
+     结构沿用全站设置页的既有语言：`.history__top` 标题栏 + `.history__group` 分组名 +
+     `.setcard` 卡片 + `.setrow` 行 + `.seg` / `.tgl`。不新造视觉，也没有说明文字。
+     分组只解决「找得到」：账户 / 引擎 / 本机偏好 / 通知与连接 / 服务 →
+     危险操作（断开连接）单独一张卡。 -->
 <div class="mine" id="mine" hidden>
   <div class="history__top">
     <button class="topbar__icon" id="btnMineBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
@@ -1425,7 +1796,38 @@ html[data-theme="dark"] .tabfab__b{
   </div>
   <div class="history__list">
     <div class="setcard">
-      <div class="setrow"><span class="setrow__l">设备</span><span class="setrow__v" id="mineDevice">—</span></div>
+      <div class="history__group">账户</div>
+      <div class="setrow">
+        <span class="setrow__l">当前桌面</span>
+        <span class="setrow__v" id="mineDevice">—</span>
+        <button class="setrow__act" type="button" id="btnMineSwitchEnv">切换</button>
+      </div>
+      <!-- 飞书推送：绑定码 / 开关 / 凭据放子页面（#feishuPage），这里只留一行入口。 -->
+      <button class="setrow" id="btnFeishuPage" type="button">
+        <span class="setrow__l">飞书推送</span>
+        <span class="setrow__v" id="feishuSummary">未绑定</span>
+      </button>
+    </div>
+
+    <div class="setcard">
+      <div class="history__group">引擎</div>
+      <!-- 默认引擎 / 模型：新建任务的初值（会话里输入框上方的级联切换会回写这里）。
+           **引擎与模型同一行**（2026-10-26 用户：「引擎和模型显示在同一行即可」）：
+           右格主行「引擎 · 模型」（放不下就折到第二行，不截断），备用再小一档跟在后面。
+           ⚠️ #defaultModel / #suggestModel 这两个 id 被 tests/check-conv-component.mjs 读，
+              现在挂在同一行里内嵌的 span 上 —— 别删 id、别把模型拆回独立一行。 -->
+      <button class="setrow setrow--engmodel" id="btnDefaultEngine"><span class="setrow__l">默认引擎</span><span class="setrow__v setrow__v--pair" id="defaultEngine">自动（首个可用）</span><span class="setrow__v setrow__v--model" id="defaultModel">跟随引擎</span></button>
+      <button class="setrow setrow--engmodel" id="btnSuggestEngine"><span class="setrow__l">建议引擎</span><span class="setrow__v setrow__v--pair" id="suggestEngine">不开启</span><span class="setrow__v setrow__v--model" id="suggestModel"></span></button>
+      <!-- 团队入口：外层 #teamCard 是**显隐开关**（paintTeamPref 按 core 能力位翻 hidden），
+           内层 #btnTeamPage 是**点击目标**。两个 id 缺一不可 —— 合成一个会让入口点不动，
+           或让「core 不支持团队」时仍亮着一个点了必然失败的设置行。 -->
+      <div class="mslot" id="teamCard">
+        <button class="setrow" id="btnTeamPage"><span class="setrow__l">团队模式</span><span class="setrow__v" id="teamSummary">跟随主引擎</span></button>
+      </div>
+    </div>
+
+    <div class="setcard">
+      <div class="history__group">本机偏好</div>
       <div class="setrow"><span class="setrow__l">主题</span>
         <span class="seg" id="segTheme">
           <button class="seg__b" data-v="system">系统</button>
@@ -1442,45 +1844,29 @@ html[data-theme="dark"] .tabfab__b{
       </div>
       <div class="setrow"><span class="setrow__l">任务模式</span>
         <span class="seg" id="segMode">
+          <button class="seg__b" data-v="auto">自动</button>
           <button class="seg__b" data-v="parallel">并行</button>
           <button class="seg__b" data-v="serial">串行</button>
         </span>
       </div>
-      <!-- 会话托管（2026-10-23 用户：「托管模式下自动按照最佳建议提交到会话中执行」；
-           同日再定：「跟团队模式一样改成挂在会话上，子会话继承，不再是全局」）。
-           所以这里**没有**全局开关 —— 与团队模式同一处入口：会话页右上角 → 任务运行设置。 -->
-      <!-- 默认引擎 / 模型：新建任务的初值（会话里输入框上方的级联切换会回写这里）。
-           两行点开的是同一个「引擎 → 模型」二列选择器，模型必须挂在引擎下。 -->
-      <!-- 默认引擎（主 + 备一屏配完，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>
     </div>
-    <!-- 团队模式（2026-10-21）：开关**按会话**给，放会话页右上角的运行设置里（与权限模式并排），
-         所以这里不展示全局面板状态；这里只放**这台设备的配置**入口 —— 具体每类任务交给谁
-         进子页面（#teamPage）再配，不在「我的」里铺五行。 -->
-    <div class="setcard" id="teamCard">
-      <button class="setrow" id="btnTeamPage"><span class="setrow__l">团队模式</span><span class="setrow__v" id="teamSummary">跟随主引擎</span></button>
+
+    <div class="setcard">
+      <div class="history__group">通知与连接</div>
+      <button class="setrow" id="btnNotify"><span class="setrow__l">系统通知</span><span class="setrow__v" id="notifyState">—</span></button>
     </div>
+
     <div class="setcard">
-      <!-- 版本号 + 升级（2026-10-22 用户：「移动端版本跟着npm走」+「在版本号的地方
-           可以显示版本也可检测最新版本号并触发升级」）。
-           显示的是 **APK 自己的版本**（构建时从 magic-agent/package.json 注入，闸门页
-           通过 ?appv= 带进来）；浏览器预览没有 appv 时才回落到桌面端 health.version。
-           点这一行就去问桌面端内置的 APK 是哪一版，新了就直接触发下载安装。 -->
+      <div class="history__group">服务</div>
+      <!-- 版本：显示 APK 自己的版本（构建时注入），点它去问桌面端是否带了更新。 -->
       <button class="setrow" id="btnMineVersion" type="button">
         <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="btnUpgrade"><span class="setrow__l">重新加载界面</span><span class="setrow__v" id="upgradeState"></span></button>
+      <!-- 重启会中断桌面端**正在跑的所有会话**，点击前二次确认。 -->
       <button class="setrow" id="btnRestartClient" type="button">
-        <span class="setrow__l">重启服务</span><span class="setrow__v" id="restartClientState">重启</span>
+        <span class="setrow__l">重启服务</span><span class="setrow__v" id="restartClientState"></span>
       </button>
     </div>
     <div class="setcard">
@@ -1489,6 +1875,21 @@ html[data-theme="dark"] .tabfab__b{
   </div>
 </div>
 
+<!-- ══════════ 我的 → 飞书推送（绑定 + 开关 + 凭据）══════════
+     2026-10-26 用户：「另增加飞书绑定支持登录后推送通知」。
+     目标：手机在后台 / 锁屏 / 离开局域网时也收得到「任务完成 / 待确认」——
+     手机端系统通知只在本页开着轮询时才响（见 pollOnce），飞书推送由**桌面端**发。
+     行由 paintFeishu() 按 GET /desk/feishu 的状态渲染（服务端宣布什么就显示什么）。 -->
+<div class="history" id="feishuPage" hidden>
+  <div class="history__top">
+    <button class="topbar__icon" id="btnFeishuBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
+    <span class="history__title">飞书推送</span>
+  </div>
+  <div class="history__list" id="feishuBody">
+    <div class="history__hint">正在读取飞书配置…</div>
+  </div>
+</div>
+
 <!-- ══════════ 我的 → 团队模式（计划 + 7 类子任务）══════════
      从「我的」那一行点进来。这里配的全都是**设备级偏好**（开关本身按会话，在会话页运行设置里）。
      **只有一套划分**：计划 + 7 个角色（writer / researcher / reviewer / coder / designer /
@@ -1586,6 +1987,15 @@ html[data-theme="dark"] .tabfab__b{
 <!-- 脚本的二级视图：详情 + 启停按钮 + 实时日志（内容由 scripts.js 渲染） -->
 <div class="history" id="scriptDetail" hidden></div>
 
+<!-- ══════════ 发现 → 应用（工作台：magic-shorts / magic-video）══════════
+     **独立子页面**：内容、样式、逻辑都在 apps.js / apps.css，本文件只留两个空容器。
+     工作台在**这台桌面**上跑，服务端负责启停；手机在内置浏览器里打开（走桌面网络）。
+     数据形状与端点见 CLIENT-CONTRACT §2（/desk/apps）。 -->
+<div class="history" id="apps" hidden></div>
+
+<!-- 应用的二级视图：启动 / 停止 / 在内置浏览器打开（内容由 apps.js 渲染） -->
+<div class="history" id="appDetail" hidden></div>
+
 <!-- ══════════ 发现 → 插件（工程 CLI 目录）══════════
      列表与详情都是**服务端宣布什么就显示什么**（GET /desk/plugins）。 -->
 <div class="history" id="plugins" hidden>
@@ -1660,6 +2070,7 @@ html[data-theme="dark"] .tabfab__b{
       <!-- 截图：只有需求页的「页面完成情况」流程走中转时才出现（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="brLand" type="button" aria-label="横屏显示" title="横屏显示" hidden><svg width="18" height="18"><use href="#i-phone"/></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>
@@ -1670,7 +2081,16 @@ html[data-theme="dark"] .tabfab__b{
     <button class="browser__app" id="brClose" type="button" aria-label="关闭浏览器">✕</button>
   </header>
   <div class="browser__stage" id="brStage">
-    <iframe class="browser__frame" id="brFrame" src="about:blank" referrerpolicy="no-referrer" allow="fullscreen"></iframe>
+    <!-- referrerpolicy：**不能**用 no-referrer（2026-10-26）。工作台（发现 → 应用）的页面从
+         /workbench/{id}/ 跳到 "/" 后，页面里的 '/api/…' 要靠 Referer 认出「这是哪个工作台」
+         （见 magic-client 的 apps.go / workbenchFor）。no-referrer 会让这些请求一个头都不带，
+         页面出来、数据全空。no-referrer-when-downgrade = 同源照带、只在不安全的降级时省略，
+         跨站隐私口径不变。 -->
+    <div class="browser__land" id="brLandHint" hidden>
+      <span><b>已转横屏</b></span>
+      <button class="browser__landbtn" id="brLandOff" type="button">竖屏</button>
+    </div>
+    <iframe class="browser__frame" id="brFrame" src="about:blank" referrerpolicy="no-referrer-when-downgrade" 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>
@@ -1728,7 +2148,7 @@ html[data-theme="dark"] .tabfab__b{
      **只有图标、没有文字**（2026-10-22 用户：「底栏只保留图标不需要文字了」）：
      语义靠 aria-label 承担。 -->
 <nav class="tabbar" id="tabbar" hidden>
-  <i class="eave eave-l" aria-hidden="true"></i><i class="eave eave-r" aria-hidden="true"></i>
+  <div class="bararc" aria-hidden="true"><svg class="bararc__svg"><path class="bararc__d"/><path class="bararc__s"/></svg></div>
   <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">
@@ -1881,14 +2301,14 @@ html[data-theme="dark"] .tabfab__b{
              填金在选中绿上只有 1.29，填孔在 28px 下糊成一团黑；
              细线两头都不犯：暗底当亮线、亮底当暗线，且不占体积。
              金丹垫 canvas 暗衬后才立得住（朱 vs 绿 2.0 → 朱 vs 暗衬 4.0）。 -->
-        <g fill="none" stroke="var(--canvas,#0B1512)" stroke-width=".62" stroke-linecap="round">
+        <g fill="none" stroke="var(--canvas,#06180F)" 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 cx="12" cy="16.15" r=".78" fill="var(--canvas,#06180F)" stroke="none"/>
         <circle class="yypill" cx="12" cy="16.15" r=".5" fill="var(--q-blood,#E23B2E)" stroke="none"/>
       </g>
     </svg></span></button>
@@ -1934,6 +2354,9 @@ html[data-theme="dark"] .tabfab__b{
 <!-- 脚本页（独立子页面模块）：只在这里加载并注册 window.MagicScripts，
      真正的 DOM/逻辑都在 scripts.js，主 IIFE 末尾 mount 时把宿主能力注入进去。 -->
 <script src="scripts.js"></script>
+<!-- 应用页（独立子页面模块）：只在这里加载并注册 window.MagicApps，
+     真正的 DOM/逻辑都在 apps.js，主 IIFE 末尾 mount 时把宿主能力注入进去。 -->
+<script src="apps.js"></script>
 <script>
 (function () {
   'use strict';
@@ -1958,12 +2381,126 @@ html[data-theme="dark"] .tabfab__b{
   var taskSearchBar = document.getElementById('taskSearchBar');
   var taskSearchInput = document.getElementById('taskSearchInput');
   var mineEl = document.getElementById('mine');
+  var feishuPageEl = document.getElementById('feishuPage');
   var mineDevice = document.getElementById('mineDevice');
   var mineVersion = document.getElementById('mineVersion');
   var segTheme = document.getElementById('segTheme');
   var segFont = document.getElementById('segFont');
   var segMode = document.getElementById('segMode');
   var tabbarEl = document.getElementById('tabbar');
+  /* 底栏弧面（见 .bararc 注释）：背景层铺满整条栏，脚本只负责往里写两条路径。
+     坐标必须用 getBoundingClientRect 量（= 屏幕上的显示尺寸），不能用 clientWidth：WebView 里设了
+     字体大小偏好时会给 body 打 zoom，那时 clientWidth 是「未缩放的布局宽度」、rect 是「缩放后的
+     显示宽度」，混用会让弧按错误的宽度画 —— 屏幕上就是左右不等宽（2026-10-25 手机截图实测）。
+
+     ⚠️⚠️ 弧的朝向（2026-10-25 用户：「现在的线是左高右低」）：
+       SVG 的 y 轴向下（y 越大越靠下）。要让「中间高、两端低、两端往上翘」的嘴角形，端点必须放在 y=0、
+       控制点放在 y=amp（把中段往下拽）。反过来（端点 y=amp、控制点 y=0）是拱桥形，左右虽然对称，
+       但人会按屏幕基线把左端读成「高」、右端一路压下去 → 就是用户看到的「左高右低」。
+       当前形状：
+         M0 0 C x1 amp, x2 amp, W 0     —— 起点 / 终点都在 y=0（两端上翘到顶）
+         控制点两边都是 y=amp（把中段往下拽，形成对称的浅盆）
+       x1 = W·K_END、x2 = W − x1 保证左右严格镜像；amp = AMP（14），屏幕上中间比两端低约 10.5px。
+     页面底色那一大片也用玉面填（路径一直落到盒子底），弧以上被切掉的部分露出页面。 */
+  (function () {
+    var arc = tabbarEl && tabbarEl.querySelector('.bararc');
+    if (!arc) return;
+    var svg = arc.querySelector('.bararc__svg');
+    var line = arc.querySelector('.bararc__s');
+    var fill = arc.querySelector('.bararc__d');
+    if (!svg || !line || !fill) return;
+    /* 端点 y=0、控制点 y=AMP → 中间低、两端翘。改这里要同步 .bararc 注释②（两处不一致会画错朝向）。 */
+    var K_END = 0.30;
+    function draw() {
+      var r = svg.getBoundingClientRect();
+      if (!r.width || !r.height) return;             /* 隐藏时量不到，等下一次触发 */
+      var W = Math.round(r.width), HH = Math.round(r.height);
+      svg.setAttribute('viewBox', '0 0 ' + W + ' ' + HH);
+      svg.setAttribute('width', String(W));
+      svg.setAttribute('height', String(HH));
+      /* ── 下沉深度**从 --arc-dip 反算**（2026-10-26 用户：「弧线距离底部的距离也固定」）──
+         弧层现在铺满**整个栏盒**（bottom:0，含安全区），端点恒定在 y=0（栏顶）。
+         要让它最深处距**内容区底**恒为 --arc-dip，则下沉量 sink = barH − arcDip。
+         而三次贝塞尔（端点 y=0、两个控制点 y=AMP）的最深处恰好是 AMP 的 3/4，
+         所以 AMP = sink / 0.75。
+         这样改 --bar-h 只会把栏顶抬高，弧线相对栏底的落点一动不动（以前 AMP 是写死的 14，
+         栏高一变，「距栏底多少」就跟着变 —— 那正是三个数互相推算的来源之一）。
+         ⚠️ 0.75 这个系数来自「控制点等高、端点等高」的对称三次贝塞尔：t=0.5 处
+            y = 3/4·AMP，只有这种形状才成立。换成两段圆弧（方案 C）要另算。
+         ⚠️⚠️ 基准必须是 **--bar-h（内容区高）**，不是 HH（= 栏盒高，含安全区）。
+            这一层铺满栏盒之后，HH 多出 --sab 那 34px；拿它算 sink 会让弧线下移 34px，
+            直接跑到图标下面去（2026-10-26 实测：最深处 y=798.5 而图标底 795）。 */
+      var barH = parseFloat(getComputedStyle(document.documentElement)
+        .getPropertyValue('--bar-h')) || 56;
+      var arcDip = parseFloat(getComputedStyle(document.documentElement)
+        .getPropertyValue('--arc-dip')) || 45.5;
+      var sink = Math.max(0, barH - arcDip);
+      var AMP = sink / 0.75;
+      var x1 = Math.round(W * K_END), x2 = W - x1;
+      /* 描边：两端 y=0，控制点 y=AMP（中间下沉，两端上翘，左右镜像）。 */
+      line.setAttribute('d', 'M0 0C' + x1 + ' ' + AMP + ' ' + x2 + ' ' + AMP + ' ' + W + ' 0');
+      /* 玉面 = 弧线以下一直到盒子底（含安全区，屏幕最底不再露页面）；沿同一条曲线封口。 */
+      fill.setAttribute('d',
+        'M0 0C' + x1 + ' ' + AMP + ' ' + x2 + ' ' + AMP + ' ' + W + ' 0V' + HH + 'H0Z');
+    }
+    requestAnimationFrame(draw);
+    if (window.ResizeObserver) new ResizeObserver(draw).observe(svg);
+    window.addEventListener('resize', draw);
+    /* 字体大小偏好（body zoom）改完不会触发 resize，切主题/字体后补画一次。 */
+    window.addEventListener('magic:fontpref', draw);
+  })();
+  /* ── 安全区冻结（见 :root 里 `--sab` 那段注释）──
+     目标：**不管键盘有没有弹起，底栏都是 56 + 34**。做法是把 env() 量成像素写进 `--sab`，
+     并且只在「键盘收起」时才允许这个值变小（键盘弹起时 env 会掉到 0 恰恰就是信号）。
+
+     为什么不用 visualViewport 的高度差判键盘：
+       Android 的 adjustResize 会**同时**缩 layout viewport 和 visual viewport，两者高度一直相等，
+       差值恒为 0 —— 拿它判键盘在真机上永远判不到（Chrome 调试器里却能复现，是典型的假阳性）。
+       env(safe-area-inset-bottom) 反而是可靠的：键盘盖住 home indicator 那一条时它必须归零。
+
+     两个状态：
+       键盘收起 → `--sab` 跟着 env 走（横竖屏切换 / 换设备时该变就变）；
+       键盘弹起（env 变小）→ `--sab` 冻住，栏高与图标位置一根毫毛不动。
+
+     ⚠️ 键盘态**不做任何额外视觉补偿**（早先试过让弧面在键盘态铺满整条栏，已撤掉）：
+     目标是两种状态长得完全一样，多一条 `html.is-kb` 分支就又多出两种样子。
+     那 34px 在键盘上面读作「栏体的下沿」，跟常规态留白的下沿是同一条线。
+
+     ⚠️ 转屏也会让 env 变小（横屏常常是 0 / 21），不能把它误判成键盘、否则横屏会白留一条。
+     判据是**宽度**：`innerWidth` 变了 80px 以上就是转屏，这时重置基线、信任新值。 */
+  var sabMax = 0, sabProbe = null, lastW = 0;
+  function sabMeasure() {
+    if (!sabProbe) {
+      sabProbe = document.createElement('div');
+      /* 高度 = env(safe-area-inset-bottom)，其余全部归零，量它不掉性能 */
+      sabProbe.style.cssText =
+        'position:fixed;left:0;bottom:0;width:0;height:env(safe-area-inset-bottom,0px);' +
+        'visibility:hidden;pointer-events:none;z-index:-1';
+      (document.body || document.documentElement).appendChild(sabProbe);
+    }
+    return sabProbe.getBoundingClientRect().height || 0;
+  }
+  function sabSync() {
+    var w = window.innerWidth || 0;
+    if (lastW && Math.abs(w - lastW) > 80) sabMax = 0;   /* 转屏：旧基线作废 */
+    lastW = w;
+    var cur = sabMeasure();
+    var kb = sabMax > 0 && cur < sabMax - 0.5;
+    /* 键盘收起（cur 追平）才允许刷新上限；转屏时基线刚清空，这里会把新值收进来。 */
+    if (!kb) sabMax = cur;
+    document.documentElement.style.setProperty('--sab', Math.round(sabMax) + 'px');
+  }
+  sabSync();
+  window.addEventListener('resize', sabSync);
+  if (window.visualViewport) {
+    window.visualViewport.addEventListener('resize', sabSync);
+    window.visualViewport.addEventListener('scroll', sabSync);
+  }
+  /* 兜底：某些 WebView 弹键盘时不一定同步触发上面的事件，输入框进出再补一次。
+     `magic:fontpref` 与弧面重画同一个来源（字体偏好改动会让 body 缩放、几何全变）。 */
+  document.addEventListener('focusin', function () { setTimeout(sabSync, 60); });
+  document.addEventListener('focusout', function () { setTimeout(sabSync, 120); });
+  window.addEventListener('magic:fontpref', sabSync);
   var reqsEl = document.getElementById('reqs');
   var reqDetailEl = document.getElementById('reqDetail');
   var discoverEl = document.getElementById('discover');
@@ -1981,6 +2518,8 @@ html[data-theme="dark"] .tabfab__b{
   var knowledgeDetailBody = document.getElementById('knowledgeDetailBody');
   var scriptsEl = document.getElementById('scripts');
   var scriptDetailEl = document.getElementById('scriptDetail');
+  var appsEl = document.getElementById('apps');
+  var appDetailEl = document.getElementById('appDetail');
   var brEl = document.getElementById('browser');
   var brFrame = document.getElementById('brFrame');
   var brAddr = document.getElementById('brAddr');
@@ -1988,6 +2527,8 @@ html[data-theme="dark"] .tabfab__b{
   var brStar = document.getElementById('brStar');
   var brRelayBtn = document.getElementById('brRelay');
   var brShotBtn = document.getElementById('brShot');
+  var brLandBtn = document.getElementById('brLand');
+  var brLandHint = document.getElementById('brLandHint');
   var readerEl = document.getElementById('reader');
   var rdTitle = document.getElementById('rdTitle');
   var rdSub = document.getElementById('rdSub');
@@ -1998,6 +2539,7 @@ html[data-theme="dark"] .tabfab__b{
 
   /* ── 当前连接：连上后由它驱动 transport ── */
   var BASE = '', TOKEN = '';
+  var TOKEN_INJECTED = '';         // 壳 / 同源页注入的令牌（见首屏），apiToken 用它兜底
   var conv = null;
   /* 当前组件里装着哪条会话 / 哪个空间：同一条会话再次打开时直接复用这一屏
      （见 mountConversation）。返回列表只是 hideAll()，组件与画面本来就还在。 */
@@ -2338,6 +2880,10 @@ html[data-theme="dark"] .tabfab__b{
   }
   function saveConns(list) {
     try { localStorage.setItem(CONN_KEY, JSON.stringify((list || []).slice(0, CONN_MAX))); } catch (e) {}
+    /* 环境列表是 PREF_SYNC_KEYS 的一员（2026-10-26：「重新安装 apk 环境就没了」），
+       所以每次落盘都要推回桌面，否则重装后拉到的还是旧的。
+       schedulePushPrefs 自带 TOKEN 守卫与 700ms 防抖，初始化阶段（还没连上）调了也不发。 */
+    try { schedulePushPrefs(); } catch (e) {}
   }
   function findConn(id) {
     var list = loadConns();
@@ -2407,6 +2953,25 @@ html[data-theme="dark"] .tabfab__b{
         否则这条「未命名」没有 URL，既存不下来也就没法编辑（2026-10-22 用户：
         「现在已有的未命名都编辑不了」）。 */
   function connUrlNow() { return BASE || (TOKEN ? location.origin : ''); }
+  /* 「请求此刻打向哪个原点」：BASE 为空时是页面自身，否则是 BASE。
+     不能直接用 connUrlNow() 判断请求地址 —— 同源页的 BASE 是空串，
+     `'' + '/desk/restart'` 打的是**页面自己**（2026-10-25 实测：重启请求发到了静态页）。 */
+  /* ⚠️ 只认 BASE **的空串**：这里若用 `BASE || …`，BASE 还是空串（连接逻辑还没落定）时
+     就会退化成 location.origin —— 同源页打自己不说，跨主机页（远程界面）会把请求打回
+     静态页上。连接逻辑落定之后 BASE 恒非空且不带尾斜杠（parseTarget / 环境记录都是），
+     空 BASE 就是「与 /desk/ 同源」。 */
+  function apiOrigin() { return BASE === '' ? location.origin : BASE; }
+  /* 本次连接用哪个令牌访问 /desk/*（同源页没注入令牌时为空串 = 不带鉴权头）。 */
+  function apiToken() { return TOKEN || (BASE === '' ? injectedToken : ''); }
+  /* 会话 / 环境用的「连接值」：同源页保持空串（与 /desk/ 同源），其它就是 BASE。 */
+  function toConnValue(u) {
+    var abs = normOrigin(u);
+    if (BASE || !abs) return String(u || '');
+    try {
+      var same = abs === location.origin;
+    } catch (e) { return String(u || ''); }
+    return same ? '' : abs;
+  }
   function activeConn() {
     var url = connUrlNow();
     var list = loadConns(), i;
@@ -2419,11 +2984,29 @@ html[data-theme="dark"] .tabfab__b{
     }
     return null;
   }
-  /* 环境显示名：扫码带的 name > 桌面 health 报的 app > host。 */
+  /* 环境显示名：扫码带的 name > 桌面 health 报的 app > host。
+     ⚠️ 这是**列表里**的标签（环境菜单 / 最近连接），它可以回落到 host；
+        「我的 → 当前桌面」那类「这台是谁」的位置要用下面的 envName()（不显示地址）。 */
   function connLabel(c) {
     if (!c) return '';
     return c.name || c.app || c.host || connHost(c.url);
   }
+  /* 「我的 → 当前桌面」/ 运行设置里的设备名：**只给名字，不给地址**
+     （2026-10-26 用户：「环境显示名字不是地址」）。
+     名字来源：用户起的 name > 桌面 health 报的 app > 同源壳连接「本机」>「未命名环境」。
+     不回落到 host / IP:端口 —— 地址属于「怎么连」，不是「这是谁」；
+     要地址的用户点「切换」进环境菜单，那里每行的副标题就是地址。
+     ⚠️ 这里返回的是「名字」，别拿它去查列表 / 做 id（那些用 connLabel / connIdOf）。 */
+  function envName(c) {
+    if (c == null) c = activeConn();
+    if (!c) return '本机';
+    var name = String(c.name || '').trim();
+    if (name) return name;
+    var app = String(c.app || '').trim();
+    if (app) return app;
+    if (String(c.url) === String(location.origin)) return '本机';
+    return '未命名环境';
+  }
   function envLabel() {
     var c = activeConn();
     if (!c) return histSubtitle || '';
@@ -2535,7 +3118,13 @@ html[data-theme="dark"] .tabfab__b{
       var o = list[k];
       /* 隧道换域名 = 同一台桌面换了入口：把它的 eid 带过去，
          否则新记录会发新号，这台环境排队中的任务与配置槽全部变孤儿。 */
-      if (o && o.seed && o.name === SEED_NAME && o.url !== url) { replacedEid = o.eid || replacedEid; continue; }
+      if (o && o.seed && o.name === SEED_NAME && o.url !== url) {
+        /* 公网域名是稳定入口：新地址只是局域网（隧道没探到 / 换了网卡）时**不要**把域名
+           那条删掉换成局域网 —— 那正是「重启 / 换网后地址变了」的来源（2026-10-25）。
+           反过来，新地址也是公网域名（隧道真换了域名）时才替换。 */
+        var oldPublic = /^https:\/\//i.test(o.url), newPublic = /^https:\/\//i.test(url);
+        if (!oldPublic || newPublic) { replacedEid = o.eid || replacedEid; continue; }
+      }
       kept.push(o);
     }
     if (kept.length !== list.length) saveConns(kept);
@@ -2682,16 +3271,67 @@ html[data-theme="dark"] .tabfab__b{
      所以这组键以 `/desk/prefs` 为准，localStorage 只当离线缓存：
        · 连上后拉一次，远端是权威 → 有差异就覆盖本地并重载一次；
        · 本地任何一处改了，防抖推回远端。
-     纯设备偏好（主题/字体/通知）**不同步** —— 那是手机自己的事。 */
+     纯设备偏好（主题/字体/通知）**不同步** —— 那是手机自己的事。
+
+     ⚠️⚠️ **环境列表（CONN_KEY）必须在这张表里**（2026-10-26 用户：「环境配置现在存在
+        哪里 重新安装apk就没了」「要解决环境保留的问题」）：
+        它原先只躺在 localStorage 里，卸载 / 清除数据 / 换手机就**全丢** —— 用户得把
+        每台桌面的地址和令牌重新手输一遍，而令牌是 magic-client 落盘复用、跨重启不变的
+        机器身份，人根本记不住。这正是「同一个环境多个客户端配置还要一致」最该覆盖的一条。
+        放进来的代价很小（就是个 JSON 数组，量级几百字节），收益是重装后自动回来。
+        ⚠️ 但**不能只靠它**：能拉到远端配置的前提是**已经连上过某台桌面**，
+           而重装后连谁都不知道（CONN_KEY 空 → 闸门页只会去试打包时注入的 DEFAULT_CONNS）。
+           所以 /desk/prefs **只管「回到那之后」的多环境列表**，
+           「第一台怎么连回去」由闸门页的多入口兜底负责 —— 见 magic-test 的
+           tools/build-mobile-www.cjs 注入的 DEFAULT_CONNS（公网 + 局域网 + 一键召回）。 */
   var PREF_SYNC_KEYS = [
     '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',
+    /* 任务模式（2026-10-26）：applyTaskModeToQueued 的注释一直写着它「随 /desk/prefs 同步」，
+       但这张表里其实从来没有它 —— 换台设备/重装后模式会退回默认。三档（自动/并行/串行）
+       是环境级设置，必须跟着环境走；判定引擎那几个键已经在上面了。 */
+    'magic.taskmode',
     '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'
+    'magic.team.parallel', 'magic.team.split', 'magic.team.splitcode', 'magic.team.adaptive',
+    'magic.remote.conns.v1'
   ];
+  /* ── 环境列表：**合并**，不是覆盖 ──
+     上面那张表其余键都是「整份语义」（默认引擎就那一个，远端说了算）。
+     环境列表不一样：它是**累积**的 —— 手机连过 A 也连过 B，这份名单就该同时有 A、B。
+     如果照抄其余键的「远端权威、有差异就覆盖」，会出两种丢数据：
+       · 远端的 prefs 是三天前推的（那时还没连 B）→ 拉下来把 B 抹掉；
+       · 换一台桌面连（它的 prefs 只有它自己）→ 拉下来把别家全抹掉，
+         用户点「切换环境」发现只剩一台，还以为是自己删了。
+     所以这个键单独走 merge：按 id 取并集，同 id 以 at 更新的那条为准
+     （改过名/改过令牌也算新），并受 CONN_MAX 上限约束。
+     ⚠️ 它也不参与「有差异就 reload」：名单变了只要重画环境菜单即可，
+        为此重载整页会把用户正在看的会话打断，得不偿失。 */
+  var CONN_SYNC_KEY = 'magic.remote.conns.v1';
+  function mergeConnJson(localStr, remoteStr) {
+    function parse(s) {
+      try {
+        var v = JSON.parse(s || '[]');
+        return Array.isArray(v) ? v.filter(function (c) { return c && c.url; }) : [];
+      } catch (e) { return []; }
+    }
+    var byId = {};
+    parse(localStr).concat(parse(remoteStr)).forEach(function (c) {
+      var id = c.id || connIdOf(c);
+      var old = byId[id];
+      /* 同一条：保留 at 更大（更新）的那份；at 缺失时优先远端（远端通常更"久"）。 */
+      if (!old || (Number(c.at) || 0) > (Number(old.at) || 0)) byId[id] = c;
+    });
+    var out = Object.keys(byId).map(function (k) { return byId[k]; });
+    out.sort(function (a, b) { return (Number(b.at) || 0) - (Number(a.at) || 0); });
+    return JSON.stringify(out.slice(0, CONN_MAX));
+  }
   var PREFS_PUSH_TIMER = 0, PREFS_PULLED = false, PREFS_PULLING = false;
+  /* pullPrefs 里合并环境列表后要顺手回推一次（把远端缺的条目补齐）。 */
+  var PREFS_NEED_PUSH = false;
+  /* 有推送在等首次 pull 落地（见 pushPrefs 的门闩）。 */
+  var PREFS_PUSH_PENDING = false;
   function collectPrefs() {
     var o = {};
     for (var i = 0; i < PREF_SYNC_KEYS.length; i++) {
@@ -2703,6 +3343,10 @@ html[data-theme="dark"] .tabfab__b{
   }
   function pushPrefs() {
     if (!TOKEN) return;
+    /* 首次 pull 还没落地：这一枪先不打（否则就是拿「本地残缺名单」覆盖远端完整名单）。
+       改由 pullPrefs 完成时补发 —— 那里会检查 PREFS_PUSH_PENDING。 */
+    if (!PREFS_PULLED) { PREFS_PUSH_PENDING = true; return; }
+    PREFS_PUSH_PENDING = false;
     try {
       fetch(BASE + '/desk/prefs', {
         method: 'PUT',
@@ -2711,6 +3355,13 @@ html[data-theme="dark"] .tabfab__b{
       }).catch(function () {});
     } catch (e) {}
   }
+  /* ⚠️⚠️ 推送必须等**首次拉取完成**（2026-10-26 实测踩过，非常隐蔽）：
+     saveConns 一改就 schedulePushPrefs，而启动流程里 saveConns 发生得**很早**
+     （闸门页跳过来 / 种子环境落盘 / noteActiveMeta 补 app 名），往往早于 pullPrefs 回来。
+     结果是：远端那份「完整的多环境列表」还没读下来，本地这份「只有当前一条」就先推上去了
+     —— 一次静默覆盖，远端从此也只剩一条，用户点「切换环境」永远只有一台。
+     这不是理论风险：清数据重装后实测，远端被覆盖成 1 条。
+     所以 push 必须挂牌：等首次 pull 落地（PREFS_PULLED）后再发，否则排队等到那时候。 */
   function schedulePushPrefs() {
     if (!TOKEN) return;
     if (PREFS_PUSH_TIMER) clearTimeout(PREFS_PUSH_TIMER);
@@ -2722,10 +3373,18 @@ html[data-theme="dark"] .tabfab__b{
     if (!TOKEN || PREFS_PULLING) return;
     PREFS_PULLING = true;
     var seq = CONN_SEQ;
+    /* 拉取卡住 / 被吞（代理、WebView 挂起）时也要放行推送，否则一次没回来的 GET
+       会把后续所有配置改动**永久**堵在门口。8 秒后无脑放行。 */
+    var release = setTimeout(function () {
+      if (PREFS_PULLED) return;
+      PREFS_PULLED = true;
+      if (PREFS_PUSH_PENDING) { PREFS_PUSH_PENDING = false; schedulePushPrefs(); }
+    }, 8000);
     fetch(BASE + '/desk/prefs', { headers: { 'X-Magic-Token': TOKEN } })
       .then(function (r) { return r.ok ? r.json() : null; })
       .then(function (v) {
         PREFS_PULLING = false;
+        clearTimeout(release);
         if (seq !== CONN_SEQ) return;
         if (!v || typeof v !== 'object' || Array.isArray(v)) { PREFS_PULLED = true; return; }
         if (!Object.keys(v).length) { PREFS_PULLED = true; pushPrefs(); return; }
@@ -2735,6 +3394,20 @@ html[data-theme="dark"] .tabfab__b{
           var cur = null;
           try { cur = localStorage.getItem(k); } catch (e) {}
           var want = Object.prototype.hasOwnProperty.call(v, k) ? String(v[k]) : null;
+          /* 环境列表走合并，不走「远端权威覆盖」（见 CONN_SYNC_KEY 上面那段）。
+             远端没这个键时也**不能**按 want===null 把它删掉 —— 那正是老版本 prefs
+             （还没同步过环境列表）会把用户多环境清空的路径。 */
+          if (k === CONN_SYNC_KEY) {
+            /* merged 是「本地 ∪ 远端」按 id 去重后的结果（见 mergeConnJson）。
+               它必然 ⊇ 本地，所以只在**真的多出新条目**时才写回；
+               写回后顺手推一次，把远端缺的那几条补齐。 */
+            var merged = mergeConnJson(cur, want);
+            if (merged !== cur) {
+              try { localStorage.setItem(k, merged); } catch (e) {}
+              PREFS_NEED_PUSH = true;
+            }
+            continue;
+          }
           if (want === cur) continue;
           try {
             if (want === null) localStorage.removeItem(k);
@@ -2743,9 +3416,28 @@ html[data-theme="dark"] .tabfab__b{
           changed = true;
         }
         PREFS_PULLED = true;
+        /* 合并出来的新名单只影响「切换环境」菜单，而那个菜单是每次点开时
+           现读 loadConns() 重画的，所以这里**不用重画、更不用重载整页**
+           （重载会打断用户正在看的会话）。只需把补齐的那几条推回远端。 */
+        if (PREFS_NEED_PUSH) {
+          PREFS_NEED_PUSH = false;
+          schedulePushPrefs();
+          changed = false;
+        }
+        /* 启动期间排队的推送（saveConns 那类）现在可以发了。
+           注意放在合并之后：这时本地已经是「并集」，推上去才不会把远端削短。 */
+        if (PREFS_PUSH_PENDING) {
+          PREFS_PUSH_PENDING = false;
+          schedulePushPrefs();
+        }
         if (changed) { try { location.reload(); } catch (e) {} }
       })
-      .catch(function () { PREFS_PULLING = false; PREFS_PULLED = true; });
+      .catch(function () {
+        PREFS_PULLING = false;
+        clearTimeout(release);
+        PREFS_PULLED = true;
+        if (PREFS_PUSH_PENDING) { PREFS_PUSH_PENDING = false; schedulePushPrefs(); }
+      });
   }
 
   /* 桌面 health 回来的应用名（app）补进当前连接：它比 host 更像「这台设备是谁」。 */
@@ -2794,10 +3486,20 @@ html[data-theme="dark"] .tabfab__b{
 
   /* ── 环境切换菜单（任务页标题点开）── */
   var envMenuEl = null, envScrimEl = null;
+  function envSwitchBtn() { return document.getElementById('btnEnvSwitch'); }
+  /* 菜单和遮罩挂在 body 上、**不随哪一页一起隐藏**：点「切换环境」会 switchEnv() → location.reload()，
+     WebView 把重载当成一次导航、旧文档不一定立刻卸载 —— 那道全屏 scrim（z-index:1200）
+     就会跟着菜单盖在新页面上，整屏只剩一张菜单（2026-10-25 实测）。
+     所以：切换前列好「重载后必关」，新文档一起步再扫一遍残留（下面这一行）。
+     只扫 .envmenu*：别的浮层（抽屉 / 图片查看）在子页面里合法存在，不能一刀切。 */
+  (function () {
+    Array.prototype.forEach.call(document.querySelectorAll('.envmenu, .envmenu__scrim'),
+      function (n) { n.remove(); });
+  })();
   function closeEnvMenu() {
     if (envMenuEl) { envMenuEl.remove(); envMenuEl = null; }
     if (envScrimEl) { envScrimEl.remove(); envScrimEl = null; }
-    var btn = document.getElementById('btnEnvSwitch');
+    var btn = envSwitchBtn();
     if (btn) btn.classList.remove('is-open');
   }
   /* 换环境 = 换一台桌面：对话、轮询、运行态都属于旧连接，必须一起收掉。
@@ -2821,6 +3523,8 @@ html[data-theme="dark"] .tabfab__b{
     var rec = upsertConn(c);                          // 保证这条在册（临时记录也能落盘）
     try { localStorage.setItem(ACTIVE_ENV_KEY, rec.url || c.url || ''); } catch (e) {}
     toast('正在切换到「' + (connLabel(c) || connHost(c.url)) + '」');
+    /* 重载前先把菜单与遮罩收掉（见 closeEnvMenu 上面那段：旧文档可能还活一会儿）。 */
+    closeEnvMenu();
     try { location.reload(); } catch (e) { location.href = location.href; }
   }
   function openEnvMenu() {
@@ -3037,7 +3741,17 @@ html[data-theme="dark"] .tabfab__b{
   }
 
   /* ══════════ 视图：启动页 → 会话列表 → 会话 ══════════ */
-  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; }
+  /* 最近一次「离开会话页」的时刻（见 hideAll 与 fireQueued 的 byRegistryOnly）：
+     不在会话页里下发的任务没有 open 帧可等，验收只能靠会话登记表。 */
+  var LEAVE_CONV_AT = 0;
+  function hideAll() {
+    launcherEl.hidden = true; historyEl.hidden = true; mineEl.hidden = true; feishuPageEl.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; appsEl.hidden = true; appDetailEl.hidden = true; sessionEl.hidden = true;
+    /* 离开会话页 = 用户决定不看这一轮了。宿主下发的那条（restoreQueue 的 fireQueued）
+       只「发、不收画面」：不在会话页里时它把 SSE 立刻掐掉，open 帧因此永远来不了，
+       那条排队行就只能一直挂着「等待中」（2026-10-23 用户：「现在是并行模式怎么还在串行等待」
+       截图里两行都停在等待中）。这里把这个等待判据放开，验收改看会话登记表（见 fireQueued）。 */
+    LEAVE_CONV_AT = Date.now();
+  }
   function setActive(name) {
     Array.prototype.forEach.call(tabbarEl.querySelectorAll('.tab'), function (b) {
       b.classList.toggle('is-on', b.getAttribute('data-tab') === name);
@@ -3074,6 +3788,11 @@ html[data-theme="dark"] .tabfab__b{
     if (window.MagicReqs && window.MagicReqs.show) window.MagicReqs.show();
   }
   function showDiscover() { hideAll(); discoverEl.hidden = false; tabbarEl.hidden = false; setActive('discover'); }
+  /* 我的 → 飞书推送（2026-10-26）。返回走 showMine()：家里那一行要按新状态重画。 */
+  function showFeishuPage() {
+    hideAll(); feishuPageEl.hidden = false; tabbarEl.hidden = true;
+    paintFeishu();
+  }
   /* 脚本页：内容与逻辑在 scripts.js（独立子页面模块），这里只负责切页。
      进页面即拉一次清单（GET /desk/scripts，只读、不启停任何东西）；
      启停与日志流由 scripts.js 自己管。 */
@@ -3082,9 +3801,15 @@ html[data-theme="dark"] .tabfab__b{
     if (window.MagicScripts && window.MagicScripts.show) window.MagicScripts.show();
   }
   function showScriptDetail() { hideAll(); scriptDetailEl.hidden = false; tabbarEl.hidden = true; }
+  /* 应用页（「发现 → 应用」）：内容与逻辑在 apps.js（独立子页面模块），这里只负责切页。
+     启停与状态轮询由 apps.js 自己管。 */
+  function showApps() { hideAll(); appsEl.hidden = false; tabbarEl.hidden = true; if (window.MagicApps && window.MagicApps.show) window.MagicApps.show(); }
+  function showAppDetail() { hideAll(); appDetailEl.hidden = false; tabbarEl.hidden = true; }
   function showMine() {
     hideAll(); mineEl.hidden = false; tabbarEl.hidden = false; setActive('mine');
-    mineDevice.textContent = histSubtitle || '本机';
+    /* 当前桌面 = 环境**名字**（用户 2026-10-26：「环境显示名字不是地址」）。 */
+    mineDevice.textContent = envName();
+    refreshFeishuSummary();   // 「账户」组的飞书推送一行：先画缓存，再拉一次状态
     paintSuggestPref();
     var ns = document.getElementById('notifyState');
     /* 权限状态只能问原生才知道（异步）—— 先按缓存画一个，再探一次回来刷新。
@@ -3109,13 +3834,22 @@ html[data-theme="dark"] .tabfab__b{
   /* ══════════ 版本号 + 升级（「我的」）══════════
      显示：优先 APK 自己的版本（构建时从 magic-agent/package.json 注入，闸门页用 ?appv=
      带进来）；浏览器预览没有 appv 时才回落到桌面端 `GET /desk/health` 的 `version`。
-     升级：点这一行 → `GET /desk/app` 问桌面端「你包里带的 APK 是哪一版」。桌面端把
-     随 npm 包发布的 release APK 放在 npm/apk/ 下，由 magic-client 直接递过来；新版本
-     就触发下载（APK 壳里走原生 MagicUpdate.open 交给系统浏览器/安装器）。
-     老插件没有 /desk/app（404）→ 提示检查失败，不把「—」当成最新版本。 */
+     升级：**两条链一起看** ——
+       · App 自己：`GET /desk/app` 问桌面端「你包里带的 APK 是哪一版」，新版本就下载安装
+         （APK 壳里走原生 MagicUpdate.open 交给系统安装器；浏览器预览退化成直接下载）。
+       · 桌面端 CLI（npm 装的那份）：`GET /desk/core` 报当前 / 盘上 / npm 最新三档，
+         `POST /desk/core/upgrade` 走 SSE 执行 `npm i -g`，成功后服务原地重启；刚装好
+         还没重启时 `restartOnly` 为真，界面只说「重启后生效」，绝不喊第二次升级（再点
+         就是降级安装）。
+     老插件没有 /desk/app 或 /desk/core（404）→ 那一条链静默跳过，不把「—」当最新版。 */
   var SERVER_VERSION = '';
   var APK_LATEST = '';   // 桌面端 npm 包里带的 APK 版本（/desk/app）；空 = 没包或还没查
+  var CORE_INFO = null;  // /desk/core 的最近一次结果（npm 那份）；null = 老插件/还没查
   function shownVersion() { return APP_VERSION || SERVER_VERSION; }
+  function coreUpdateReady() {
+    return !!(CORE_INFO && CORE_INFO.upgradable && CORE_INFO.latest &&
+      cmpVersion(CORE_INFO.latest, CORE_INFO.installed || CORE_INFO.version) > 0);
+  }
   function paintMineVersion() {
     if (!mineVersion) return;
     var v = shownVersion();
@@ -3124,35 +3858,58 @@ html[data-theme="dark"] .tabfab__b{
     if (v && APK_LATEST && cmpVersion(APK_LATEST, v) > 0) {
       mineVersion.textContent = txt + ' · 升级 v' + APK_LATEST;
       mineVersion.classList.add('is-upgradable');
+    } else if (coreUpdateReady()) {
+      mineVersion.textContent = txt + ' · 桌面可升级 v' + CORE_INFO.latest;
+      mineVersion.classList.add('is-upgradable');
+    } else if (CORE_INFO && CORE_INFO.restartOnly) {
+      mineVersion.textContent = txt + ' · 桌面待重启';
+      mineVersion.classList.add('is-upgradable');
     } else {
       mineVersion.textContent = txt;
       mineVersion.classList.remove('is-upgradable');
     }
     /* 两个版本不一致时把桌面端版本放进 title：排查「App 是新的、桌面还是旧的」用得上。 */
-    mineVersion.title = (APP_VERSION && SERVER_VERSION && APP_VERSION !== SERVER_VERSION)
-      ? ('App v' + APP_VERSION + ' · 桌面 v' + SERVER_VERSION) : '';
+    var bits = [];
+    if (APP_VERSION && SERVER_VERSION && APP_VERSION !== SERVER_VERSION) {
+      bits.push('App v' + APP_VERSION + ' · 桌面 v' + SERVER_VERSION);
+    }
+    if (CORE_INFO && CORE_INFO.installed && SERVER_VERSION && CORE_INFO.installed !== SERVER_VERSION) {
+      bits.push('桌面盘上 v' + CORE_INFO.installed);
+    }
+    mineVersion.title = bits.join(' · ');
   }
-  /* 进入「我的」时静默问一次桌面端带的是哪一版 APK：有更新就把版本格变成「升级」。
-     失败（老插件没有 /desk/app）就不动，不打扰。 */
+  function appInfo() {
+    if (!TOKEN) return Promise.resolve(null);
+    return fetch(BASE + '/desk/app', { headers: { 'X-Magic-Token': TOKEN } })
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .catch(function () { return null; });
+  }
+  function coreInfo() {
+    if (!TOKEN) return Promise.resolve(null);
+    return fetch(BASE + '/desk/core', { headers: { 'X-Magic-Token': TOKEN } })
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .catch(function () { return null; });
+  }
+  /* 进入「我的」时静默问一次（APK / npm 各一条）：有更新就把版本格变成「升级」。
+     失败（老插件没有这两个接口）就不动，不打扰。 */
   function probeAppUpdate() {
     if (!TOKEN) return;
-    fetch(BASE + '/desk/app', { headers: { 'X-Magic-Token': TOKEN } })
-      .then(function (r) { return r.ok ? r.json() : null; })
-      .then(function (a) { APK_LATEST = (a && a.version) || ''; paintMineVersion(); })
-      .catch(function () {});
+    appInfo().then(function (a) { APK_LATEST = (a && a.version) || ''; paintMineVersion(); });
+    coreInfo().then(function (c) { CORE_INFO = c; paintMineVersion(); });
   }
   function refreshMineVersion() {
-    if (!TOKEN) { paintMineVersion(); return; }
-    var hdr = { 'X-Magic-Token': TOKEN };
+    /* 同源页（壳 / 远程界面）BASE 为空、令牌是注入的：用 apiOrigin / apiToken 别打到自己身上。 */
+    if (!apiToken()) { paintMineVersion(); return; }
+    var hdr = { 'X-Magic-Token': apiToken() };
     var seq = CONN_SEQ;   // 切环境后旧桌面的响应不许写到新连接上
     /* ⚠️ /desk/health.version 是 magic-client **启动时**缓存的 core 版本：客户端比 core 旧
        （升级了 CLI 但没重启服务）时会一直报旧值（实测 v1.0.111 / 实际 2.1.3）。
        /desk/contract 每次都重新问 core，才是「此刻真正的 magic-agent 版本」。
        两个并行拿：contract 权威，拿不到（老插件）才退回 health；health 还带 app 身份。 */
-    var pContract = fetch(BASE + '/desk/contract', { headers: hdr })
+    var pContract = fetch(apiOrigin() + '/desk/contract', { headers: hdr })
       .then(function (r) { return r.ok ? r.json() : null; })
       .catch(function () { return null; });
-    var pHealth = fetch(BASE + '/desk/health', { headers: hdr })
+    var pHealth = fetch(apiOrigin() + '/desk/health', { headers: hdr })
       .then(function (r) { return r.ok ? r.json() : null; })
       .catch(function () { return null; });
     Promise.all([pContract, pHealth]).then(function (a) {
@@ -3194,22 +3951,119 @@ html[data-theme="dark"] .tabfab__b{
     } catch (e) {}
     location.href = url;
   }
+  /* 跑 `POST /desk/core/upgrade` 的 SSE 流。用 XHR 而不是 fetch().body：Android WebView
+     上 response.body 的可用性随版本漂，XHR 的 onprogress 到处都有，还能逐行拿到进度。
+     返回的 Promise 以 end 事件（{ok, error, note, restarting, core}）为准。 */
+  function postCoreUpgrade(onEvent) {
+    return new Promise(function (resolve, reject) {
+      var xhr = new XMLHttpRequest();
+      xhr.open('POST', BASE + '/desk/core/upgrade', true);
+      xhr.setRequestHeader('X-Magic-Token', TOKEN);
+      var seen = 0, buf = '', endEvt = null;
+      function drain() {
+        var txt = xhr.responseText || '';
+        if (txt.length <= seen) return;
+        buf += txt.slice(seen);
+        seen = txt.length;
+        var chunks = buf.split('\n\n');
+        buf = chunks.pop();
+        chunks.forEach(function (chunk) {
+          var ev = 'message', data = '';
+          chunk.split('\n').forEach(function (ln) {
+            if (ln.indexOf('event:') === 0) ev = ln.slice(6).trim();
+            else if (ln.indexOf('data:') === 0) data = ln.slice(5).trim();
+          });
+          if (!data) return;
+          var obj = null;
+          try { obj = JSON.parse(data); } catch (e) { return; }
+          if (ev === 'end') endEvt = obj;
+          else if (onEvent) onEvent(ev, obj);
+        });
+      }
+      xhr.onprogress = drain;
+      xhr.onerror = function () { reject(new Error('网络中断，升级结果未知（可重进「我的」看版本）')); };
+      xhr.onload = function () {
+        drain();
+        if (xhr.status !== 200) {
+          var m = '';
+          try { m = (JSON.parse(xhr.responseText) || {}).error || ''; } catch (e) {}
+          reject(new Error(m || ('HTTP ' + xhr.status)));
+          return;
+        }
+        if (!endEvt) { reject(new Error('升级流没有正常结束，可重进「我的」看版本')); return; }
+        resolve(endEvt);
+      };
+      xhr.send();
+    });
+  }
+  /* 桌面端（npm）升级：进度写进版本格，结束后把结果如实说出来。 */
+  function upgradeCoreCli() {
+    var last = '正在升级桌面端…';
+    mineVersion.textContent = last;
+    mineVersion.classList.add('is-upgradable');
+    return postCoreUpgrade(function (ev, o) {
+      if (ev !== 'line' || !o || !o.line) return;
+      var ln = String(o.line).replace(/\s+$/, '');
+      if (!ln) return;
+      last = '升级中 · ' + (ln.length > 16 ? ln.slice(0, 16) + '…' : ln);
+      mineVersion.textContent = last;
+    }).then(function (end) {
+      CORE_INFO = (end && end.core) || CORE_INFO;
+      paintMineVersion();
+      if (!end || !end.ok) {
+        toast('桌面端升级失败：' + ((end && end.error) || '未知原因'));
+        return false;
+      }
+      toast(end.note || '桌面端已升级');
+      return true;
+    }, function (err) {
+      paintMineVersion();
+      toast('桌面端升级未执行：' + ((err && err.message) || err));
+      return false;
+    });
+  }
+  /* 「检测更新」：APK 与桌面端（npm）一起查，一次性把两条链的结果摆出来。
+     顺序上先升桌面端、再下 APK —— 打开系统安装器会切走 App，之后就走不了 SSE 了。 */
   function checkAppUpdate() {
     var cur = shownVersion();
     if (!TOKEN) { toast('请先连接桌面端'); return; }
     if (!cur) { toast('版本还没拿到，等列表加载完再试'); return; }
     mineVersion.textContent = '检测中…';
-    fetch(BASE + '/desk/app', { headers: { 'X-Magic-Token': TOKEN } })
-      .then(function (r) { return r.ok ? r.json() : null; })
-      .then(function (a) {
-        paintMineVersion();
-        if (!a || !a.version) { toast('桌面端没有内置安装包'); return; }
-        if (cmpVersion(a.version, cur) <= 0) { toast('已是最新版本 v' + cur); return; }
-        if (!confirm('发现新版本 v' + a.version + '（当前 v' + cur + '），现在下载升级？')) return;
+    Promise.all([appInfo(), coreInfo()]).then(function (r) {
+      var a = r[0], c = r[1];
+      APK_LATEST = (a && a.version) || '';
+      CORE_INFO = c;
+      paintMineVersion();
+
+      var appNew = !!(a && a.version && cmpVersion(a.version, cur) > 0);
+      var coreNew = !!(c && c.upgradable && c.latest &&
+        cmpVersion(c.latest, c.installed || c.version) > 0);
+      var coreRestart = !!(c && c.restartOnly);
+      var coreCan = !!(c && c.canUpgrade);
+
+      var lines = [];
+      if (appNew) lines.push('App v' + cur + ' → v' + a.version);
+      if (coreNew) {
+        lines.push('桌面端 v' + (c.installed || c.version) + ' → v' + c.latest +
+          (coreCan ? '（装好需重启 magic-client）' : '（本机没有 npm，请手工升级）'));
+      }
+      if (coreRestart && !coreNew) lines.push('桌面端 v' + c.installed + ' 已装好，重启 magic-client 后生效');
+      if (!lines.length) {
+        toast('已是最新：App v' + cur + (c && c.installed ? ' · 桌面 v' + c.installed : ''));
+        return;
+      }
+      if (!confirm('发现更新：\n' + lines.join('\n') + '\n\n现在升级？')) return;
+
+      var doCore = coreNew && coreCan;
+      var doApp = appNew;
+      var chain = Promise.resolve(true);
+      if (doCore) chain = upgradeCoreCli();
+      chain.then(function () {
+        if (!doApp) { if (coreRestart && !doCore) refreshMineVersion(); return; }
         openApkDownload(a);
-        toast('正在下载 v' + a.version + '，完成后点安装');
-      })
-      .catch(function () { paintMineVersion(); toast('检查更新失败，请确认桌面端已升级'); });
+        toast('正在下载 App v' + a.version + '，完成后点安装');
+      });
+    }).catch(function () { paintMineVersion(); toast('检查更新失败，请确认桌面端已升级'); });
   }
   /* 「我的」→ 团队模式：整块配置进子页面（与插件列表同一套子页面范式）。 */
   function showTeamPage() {
@@ -3443,7 +4297,7 @@ html[data-theme="dark"] .tabfab__b{
                   renderPlugins();
                 }
               }
-              if (!line) return;
+              if (!svg || !line) return;
               PLUGIN_LOG[id] = (PLUGIN_LOG[id] || '') + line;
               if (log) { log.textContent = PLUGIN_LOG[id]; log.scrollTop = log.scrollHeight; }
             });
@@ -3705,7 +4559,7 @@ html[data-theme="dark"] .tabfab__b{
                   renderKnowledge();
                 }
               }
-              if (!line) return;
+              if (!svg || !line) return;
               KNOWLEDGE_LOG[id] = (KNOWLEDGE_LOG[id] || '') + line;
               if (log) { log.textContent = KNOWLEDGE_LOG[id]; log.scrollTop = log.scrollHeight; }
             });
@@ -3773,7 +4627,20 @@ html[data-theme="dark"] .tabfab__b{
     catch (e) { return []; }
   }
   function saveStars(a) { try { localStorage.setItem(BR_STAR_KEY, JSON.stringify(a)); } catch (e) {} }
+  /* 应用页（发现 → 应用）打开的工作台：地址栏显示应用名，而不是 "/?via=magic-shorts"。 */
+  var BR_APP_NAMES = { 'magic-shorts': 'magic-shorts 工作台', 'magic-video': 'magic-video 工作台' };
+  function brAppId(u) {
+    try {
+      var a = new URL(u, location.origin);
+      var m = /^\/workbench\/([^/]+)/.exec(a.pathname);
+      if (m) return decodeURIComponent(m[1]);
+      var via = a.searchParams.get('via');
+      return via || '';
+    } catch (e) { return ''; }
+  }
   function siteName(u) {
+    var appId = brAppId(u);
+    if (appId) return BR_APP_NAMES[appId] || appId;
     for (var i = 0; i < BR_SITES.length; i++) { if (BR_SITES[i].url === u) return BR_SITES[i].name; }
     try { return new URL(u).host; } catch (e) { return u; }
   }
@@ -3786,6 +4653,7 @@ html[data-theme="dark"] .tabfab__b{
   }
   function brNav(url) {
     if (!/^https?:\/\//i.test(url)) url = 'https://' + url;
+    brAppEntry = '';   // 手输 / 点快捷站点 = 离开应用入口，刷新照旧重载当前站
     brStack.push(url);
     brLoad(url);
     brPaint();
@@ -3817,6 +4685,11 @@ html[data-theme="dark"] .tabfab__b{
   /* iframe 加载：**默认直连**，走手机自己的网络 —— 内置浏览器首先得是个浏览器
      （2026-10-25 用户：「没开网络代理时就应该直连啊」）。brRelayOn 开时走 /b/ 中转。 */
   function brLoad(u) { brFrame.src = brRelayOn() ? brProxyURL(u) : u; }
+  /* 每次导航完重新判断要不要横屏；换站时把上一次的手动选择清掉（新页面重新自动判断）。 */
+  brFrame.addEventListener('load', function () {
+    if (brFrame.src === 'about:blank') return;
+    brScheduleLandscape();
+  });
   function brPaintRelay() {
     if (brRelayBtn) brRelayBtn.classList.toggle('is-on', brRelayOn());
   }
@@ -3829,6 +4702,10 @@ html[data-theme="dark"] .tabfab__b{
     if (brStack.length) brReload();   // 立刻按新方式重载当前页
   }
   function openBrowser(url) {
+    brAppEntry = '';
+    brLandAppId = '';
+    brLandByUser = false;
+    brSetLandscape(false);
     brStack = [url || HOME_URL];
     brLoad(brStack[0]);
     brPaint();
@@ -3836,7 +4713,9 @@ html[data-theme="dark"] .tabfab__b{
     brEl.hidden = false;
   }
   function closeBrowser() {
-    brEl.hidden = true; brStack = []; brFrame.src = 'about:blank';
+    brEl.hidden = true; brStack = []; brAppEntry = ''; brFrame.src = 'about:blank';
+    brLandByUser = false;
+    brSetLandscape(false);
     brResetFloat();
     /* 截图流程收尾：关掉浏览器就意味着这次截图不做了 —— 把通道与按钮都收掉，
        否则下一次打开浏览器还挂着一个指向旧任务的截图入口。 */
@@ -3867,9 +4746,12 @@ html[data-theme="dark"] .tabfab__b{
     else closeBrowser();
   }
   function brHome() { brStack = [HOME_URL]; brLoad(HOME_URL); brPaint(); }
-  function brReload() { if (brStack.length) { brLoad(brStack[brStack.length - 1]); brPaint(); } }
+  function brReload() {
+    if (brAppEntry) { brStack = [brAppEntry]; brLoad(brAppEntry); brPaint(); return; }
+    if (brStack.length) { brLoad(brStack[brStack.length - 1]); brPaint(); }
+  }
   function brShare() {
-    var u = brStack[brStack.length - 1] || HOME_URL;
+    var u = brAppEntry ? new URL(brAppEntry, location.origin).href : (brStack[brStack.length - 1] || HOME_URL);
     if (navigator.share) { navigator.share({ title: siteName(u), url: u }).catch(function () {}); return; }
     try {
       if (navigator.clipboard && navigator.clipboard.writeText) {
@@ -3880,7 +4762,7 @@ html[data-theme="dark"] .tabfab__b{
     toast('当前环境不支持分享');
   }
   function brToggleStar() {
-    var u = brStack[brStack.length - 1] || HOME_URL;
+    var u = brAppEntry ? new URL(brAppEntry, location.origin).href : (brStack[brStack.length - 1] || HOME_URL);
     var stars = loadStars();
     var i = stars.indexOf(u);
     if (i >= 0) { stars.splice(i, 1); toast('已取消收藏'); }
@@ -3995,6 +4877,31 @@ html[data-theme="dark"] .tabfab__b{
     else { brEl.style.left = ''; brEl.style.top = ''; brUnfitStage(); }
   }
 
+  /* 应用页（发现 → 应用）打开工作台：**专用入口**。
+     与 openBrowser 只差一点：对它来说「刷新 / 分享 / 收藏」指的是**工作台入口**
+     （/workbench/{id}/），而不是页面最后停在的 "/" —— "/" 是手机界面的入口，
+     分享出去或点了刷新都毫无意义，而带 via= 的最后的地址刷新时会先探活，
+     工作台没在跑就得到一句人话（而不是一个打不开的白屏）。
+     ⚠️ 打开后不重新加载：工作台自己 302 到 "/" 是服务端的正常一跳，不是「来了个新站」。 */
+  var brAppEntry = '';   // 非空 = 这次打开的是应用工作台，值是它的入口
+  function openAppInBrowser(u, appOpts) {
+    appOpts = appOpts || {};
+    brAppEntry = u || '';
+    brLandAppId = String(appOpts.id || brAppId(u) || '');
+    brLandByUser = false;
+    brSetLandscape(false);
+    brStack = [u || HOME_URL];
+    brLoad(brStack[0]);
+    brPaint();
+    brResetFloat();
+    brEl.hidden = false;
+    /* 应用自己声明「按宽屏排版」且用户没拒绝过 → 竖屏下直接转。
+       页面加载后的溢出检测（brScheduleLandscape）只作兜底，见 brNeedLandscape 的注释。 */
+    var wantLand = ('landscape' in appOpts) ? !!appOpts.landscape : !!BR_APP_LANDSCAPE[brLandAppId];
+    if (wantLand && !brLandRefused(brLandAppId) && window.innerWidth <= window.innerHeight) {
+      brSetLandscape(true);
+    }
+  }
   /* 复位到全屏初始态：openBrowser（新开一站）与 closeBrowser（彻底关）都走这里。 */
   function brResetFloat() {
     brMode = 'full';
@@ -4031,9 +4938,123 @@ html[data-theme="dark"] .tabfab__b{
     var k = sw / BR_VW;                        // 等比缩放系数
     brFrame.style.transform = 'scale(' + k + ')';
   }
+  /* ── 横屏（2026-10-27）──
+     magic-video / magic-shorts 的工作台是**桌面宽屏**排版（三栏 / 双栏）。塞进手机竖屏
+     的 iframe 里，右半边直接被切掉，用户看到的就是「打不开」。两个工作台又都是同源
+     反代进来的，所以能直接读 iframe 里的真实布局宽度做判断 —— 不靠应用自己声明：
+       1) 页面加载完（工作台是 JS 渲染，得等一会儿）量 scrollWidth；
+       2) 溢出超过 25% 就转横屏：iframe 自身尺寸换成「高×宽」再 rotate 90°，
+          旋转后的可视区域正好铺满舞台（origin 0 0 + translateX(W)）；
+       3) 顶部一条提示说明「已按横屏显示」并给「切回竖屏」；手动切过就记住，
+          不再自动转（自动改变方向又不听人劝，是最烦的那种聪明）。
+     手机自己横过来（innerWidth > innerHeight）时不转 —— 那时设备已经横了，
+     再转一次就变成歪的。悬浮态不支持横屏：尺寸模型是 16:9 等比缩放，会打架。 */
+  var brLand = false;          // 当前是否软件横屏
+  var brLandByUser = false;    // 用户手动切过：之后不再自动判断
+  var brLandTimer = 0;
+  var brLandAppId = '';        // 这次打开的是哪个应用（'' = 普通网页）
+  /* 用户手动选的「这个应用不要横屏」要记住 —— 否则每次打开都被转一次，
+     那不叫自动，那叫跟人较劲。key 里带应用 id，互不影响。 */
+  var BR_LAND_KEY = 'magic.browser.landoff.v1';
+  /* 与 magic-client 的 apps.go（appSpec.Landscape）同一份口径：这些工作台按桌面宽屏排版。
+     前端留一份的原因：界面是静态资源，同步后刷新就生效，不用为了一个布尔值重启服务；
+     后端 /desk/apps 里的 landscape 字段优先（有就以它为准）。 */
+  var BR_APP_LANDSCAPE = { 'magic-video': true };
+  function brLandOffList() {
+    try { var a = JSON.parse(localStorage.getItem(BR_LAND_KEY) || '[]'); return Array.isArray(a) ? a : []; }
+    catch (e) { return []; }
+  }
+  function brLandRefused(id) { return !!id && brLandOffList().indexOf(id) >= 0; }
+  function brRememberLandOff(id, off) {
+    if (!id) return;
+    var a = brLandOffList().filter(function (x) { return x !== id; });
+    if (off) a.push(id);
+    try { localStorage.setItem(BR_LAND_KEY, JSON.stringify(a)); } catch (e) {}
+  }
+
+  function brStageEl() { return document.getElementById('brStage'); }
+
+  function brSetLandscape(on, byUser) {
+    if (byUser) {
+      brLandByUser = true;
+      if (brLandAppId) brRememberLandOff(brLandAppId, !on);   // 切回竖屏 = 记住「这个应用别转」
+    }
+    if (!on) {
+      brLand = false;
+      brEl.classList.remove('is-land');
+      brUnfitStage();
+      if (brLandHint) brLandHint.hidden = true;
+      brPaintLandBtn();
+      return;
+    }
+    if (brMode !== 'full') brResetFloat();   // 悬浮态与横屏互斥
+    var stage = brStageEl();
+    if (!stage) return;
+    var W = stage.clientWidth, H = stage.clientHeight;
+    if (!W || !H) return;
+    brLand = true;
+    brEl.classList.add('is-land');
+    brFrame.style.width = H + 'px';
+    brFrame.style.height = W + 'px';
+    brFrame.style.transformOrigin = '0 0';
+    brFrame.style.transform = 'translateX(' + W + 'px) rotate(90deg)';
+    if (brLandHint) brLandHint.hidden = false;
+    brPaintLandBtn();
+  }
+
+  function brPaintLandBtn() {
+    if (brLandBtn) brLandBtn.classList.toggle('is-on', brLand);
+  }
+
+  /* 页面到底需不需要横屏：读 iframe 文档的真实宽度（同源才读得到）。
+     溢出 25% 以上才算 —— 差几个像素是滚动条和圆角，不该把屏幕转过去。 */
+  function brNeedLandscape() {
+    if (!brFrame || brEl.hidden) return false;
+    try {
+      var d = brFrame.contentDocument;
+      if (!d || !d.documentElement) return false;
+      var sw = Math.max(d.documentElement.scrollWidth || 0, d.body ? d.body.scrollWidth || 0 : 0);
+      var vw = brFrame.clientWidth || 0;
+      if (!sw || !vw) return false;
+      /* 阈值 1.05：magic-video 竖屏下只溢出 34/390 ≈ 8.7%，却是**顶栏那排 tab 被切掉**
+         （实测 2026-10-27）。等溢出到 25% 才转，等于永远不转。 */
+      return sw > vw * 1.05;
+    } catch (e) { return false; }   // 跨域读不到 → 不自动转，用户可以点按钮
+  }
+
+  function brAutoLandscape() {
+    if (brLandByUser || brEl.hidden) return;
+    if (brLandRefused(brLandAppId)) {              // 用户明确说过这个应用别转
+      if (brLandBtn) brLandBtn.hidden = !brLand;
+      return;
+    }
+    if (window.innerWidth > window.innerHeight) {   // 设备已经横着
+      if (brLand) brSetLandscape(false);
+      return;
+    }
+    var need = brNeedLandscape();
+    if (brLandBtn) brLandBtn.hidden = !need && !brLand;
+    if (need && !brLand) brSetLandscape(true);
+    else if (!need && brLand) brSetLandscape(false);
+  }
+
+  /* 加载后量三次：工作台先出骨架、再填数据，宽度会变两次。 */
+  function brScheduleLandscape() {
+    if (brLandTimer) { clearTimeout(brLandTimer); brLandTimer = 0; }
+    if (brLandByUser) return;
+    [700, 1800, 3500].forEach(function (ms) {
+      setTimeout(function () {
+        if (brEl.hidden) return;
+        brAutoLandscape();
+        if (brLand) brSetLandscape(true);   // 尺寸可能已变，重算旋转
+      }, ms);
+    });
+  }
+
   function brUnfitStage() {
     brFrame.style.width = '';
     brFrame.style.height = '';
+    brFrame.style.transformOrigin = '';
     brFrame.style.transform = '';
   }
 
@@ -4116,10 +5137,47 @@ html[data-theme="dark"] .tabfab__b{
     else document.documentElement.removeAttribute('data-theme');
   }
   /* 字体大小：组件尺寸是 px，改 root font-size 无效；用 body zoom 整体缩放（WebView 支持）。 */
-  function applyFontPref(v) { try { document.body.style.zoom = (v && v !== '1') ? v : ''; } catch (e) {} }
-  /* 任务模式：parallel（默认，全部并行）| serial（同一空间同时只跑一个新任务）。 */
-  var TASK_MODE = 'parallel';
-  try { TASK_MODE = localStorage.getItem('magic.taskmode') || 'parallel'; } catch (e) {}
+  function applyFontPref(v) {
+    try { document.body.style.zoom = (v && v !== '1') ? v : ''; } catch (e) {}
+    /* zoom 改变后布局宽度不变、显示宽度变了，靠 resize 事件补不到；通知底栏弧面重画（见 .bararc 脚本）。 */
+    try { window.dispatchEvent(new Event('magic:fontpref')); } catch (e) {}
+  }
+  /* 任务模式（2026-10-26 增加 auto，并成为默认）：
+     · auto      —— 新会话提交时由服务端判断「本轮要干的事」与同空间运行中任务是否冲突：
+                    冲突走串行等待，不冲突照常并行（先规则，再建议引擎快速判断，默认并行）。
+     · parallel  —— 用户明确要全部并行，不做冲突判断。
+     · serial    —— 用户明确要同一空间同时只跑一个。
+     老值原样兼容：存过 parallel / serial 的用户不受影响。 */
+  var TASK_MODE = 'auto';
+  try {
+    var _tm = localStorage.getItem('magic.taskmode');
+    /* 白名单兜底：存过什么怪值（手改 / 老版本遗留）都退回默认 auto，别让界面无高亮、
+       下发时又落到某个隐含档位。 */
+    if (_tm === 'auto' || _tm === 'parallel' || _tm === 'serial') TASK_MODE = _tm;
+  } catch (e) {}
+  /* 任务模式 → 下发字段。三档的差别全在这里，别再各处写 `TASK_MODE === 'serial'` ——
+     那正是「客户端以为并行、服务端按串行处理」反复出问题的根源（见下面几处下发点）。
+     · auto：mode=auto，串行与否由服务端裁决；serial 传 false 只是给不认识 mode 的老服务端兜底
+       （不传的话它按「nil = 串行」处理，自动模式就退化成串行）。
+     · parallel：必须**显式** false（服务端默认是串行）。
+     · serial：true。
+     判定引擎用「建议引擎」那套配置（SUGGEST.*）：同一份引擎/模型/额度，用户不用为判定再配一遍。 */
+  /* 三档都写成 mode（2026-10-26 用户：「模式判断要拦截每个会话，如果不是自动就按
+     选择模式处理」）。以前只有 auto 发 mode、并行/串行靠 serial 布尔，服务端只认 auto，
+     于是「显式选了并行」在只发 mode 的调用方那里会被缺省串行吃掉。现在 mode 说了算，
+     serial 照旧一起发 —— 老服务端不认 mode 时还有它兜底，不会把并行变成串行。 */
+  function applyTaskModeToPayload(p) {
+    if (!p) return p;
+    p.mode = (TASK_MODE === 'parallel' || TASK_MODE === 'serial') ? TASK_MODE : 'auto';
+    if (TASK_MODE === 'auto') {
+      p.serial = false;
+      if (SUGGEST && SUGGEST.engine) p.judgeEngine = SUGGEST.engine;
+      if (SUGGEST && SUGGEST.model) p.judgeModel = SUGGEST.model;
+    } else {
+      p.serial = (TASK_MODE === 'serial');
+    }
+    return p;
+  }
   /* 会话托管（2026-10-23）：跟团队模式一样**挂在会话上**（用户：「跟团队模式一样改成
      挂在会话上，子会话继承，不再是全局」）。`sessions` 是 sid → 开/关；`fresh` 只临时装
      「新会话还没拿到 session_id 时」的开关（首帧带回 id 就落到 `sessions` 上）。
@@ -4476,7 +5534,7 @@ html[data-theme="dark"] .tabfab__b{
     try { localStorage.setItem(ACTIVE_ENV_KEY, c.url || target.url || ''); } catch (e) {}
     showError('');
     showHistory(c.host || '');
-    startPoll();
+    ensureNotifyPoll();      // 通知轮询（见 ensureNotifyPoll）
     restoreQueue();          // 上次没轮到的排队任务：连上就接着排（见 restoreQueue）
   }
   function disconnect() {
@@ -4519,8 +5577,7 @@ html[data-theme="dark"] .tabfab__b{
      在这份列表上不会自己冒出来（得先退出这张页再进来）。而用户要的正是「多个客户端马上就能
      看到正在跑的回话」。这里每 5s 拉一次 `/desk/sessions`；**只有在清单真的变了时才重绘** ——
      没变就不动 DOM（整表重绘会闪、还会丢滚动位置，见 renderSessions 的注释）。
-     进度那一列不靠重绘：RUN_TICK 每 3s 就地刷「第 N 步」与时长（见 tickRunning）。 */
-  var LIST_POLL = null;
+     运行中那一列不靠重绘：RUN_TICK 每 3s 就地刷运行时长（见 tickRunning）。 */
   function sessionSig(list) {
     /* 带 status：会话级状态变化（status 变了、row 的 state 可能没变）要能触发重绘。
        父字段也要比：子会话**挂在哪条主会话下面**是结构信息，父会话晚到/换 id 时
@@ -4530,36 +5587,109 @@ html[data-theme="dark"] .tabfab__b{
         + ':' + (s.parent_session_id || '') + ':' + (s.parent_run_id || '');
     }).join('|');
   }
-  function startListPoll() {
-    if (LIST_POLL) return;
-    LIST_POLL = setInterval(function () {
-      if (historyEl.hidden) return;                       // 只在这张页可见时拉
-      if (!TOKEN) return;                                 // 还没配对，拉也拉不到
-      var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
-      var seq = CONN_SEQ;
-      /* 排队 / 运行状态变化也要能触发重绘：旧服务端的排队作业根本不在 /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 })
+  /* ── 页面级的「那一份」清单（2026-10-26 合并轮询）──
+     合并前页面上有两个各跑 5s 的定时器，**各自**拉一次 /desk/sessions：
+       · startListPoll   —— 列表页可见时才拉，比签名决定要不要重绘；
+       · startPoll       —— 通知用，判状态跳变（列表页不可见时也在跑，因为要弹通知）。
+     两者一拍撞在一起时就是同一秒两个请求；再叠上 loadSessions 一次并发 5 个接口，
+     就是用户看到的「一会儿卡一下」。后端已加了 TTL 缓存 + 单飞（见
+     internal/client/sessions_cache.go），但**这里省掉的是整条往返**，比缓存命中更便宜。
+
+     合成一份之后的口径：一次 tick 只拉一次清单，**同时**喂给两个消费者 ——
+       ① 列表：可见时才比签名重绘（不可见就不动 DOM）；
+       ② 通知：永远判跳变（这是后台通知的唯一来源，不能因为列表不可见就停）。
+     jobs 只在列表页可见时才拉（它只影响列表里的「等待中」行，通知不看它）。
+
+     ⚠️ 谁在什么时候 tick：**只有** startPoller 里的那一个 setInterval（幂等）。
+        startListPoll / startPoll 都只往 pollConsumers 里登记一个消费者，
+        谁也不许自己再 setInterval —— 自挂的两个 5s 钟相位必然错开，
+        「同一拍复用」挡不住错开两秒的撞车，请求数照样翻倍。
+     ⚠️ BASE/TOKEN 还没落定时不拉（还没配对，拉了也是 401）。
+
+     消费者契约（pollConsumers 的每个成员）：
+       wants() → 现在要不要跑（列表那条用它判「这张页可见吗」）
+       jobs()  → 要不要顺带拉 /desk/jobs（只有列表需要）
+       run(list, jobs) → 拿到清单后做什么 */
+  var pollConsumers = {};
+  var POLLER = null;
+  var POLL_INTERVAL_MS = 5000;
+  /* startPoller 幂等：把所有该跑的消费者合成**一个** tick。 */
+  function startPoller() {
+    if (POLLER) return;
+    POLLER = setInterval(tickPoller, POLL_INTERVAL_MS);
+  }
+  /* tickPoller 一轮：先看有没有消费者要跑；要跑就**只拉一次**清单，
+     再分发给每个消费者（通知消费者恒在，见 startPoll）。 */
+  function tickPoller() {
+    if (!BASE && !TOKEN) return;
+    var active = [];
+    var wantJobs = false;
+    for (var k in pollConsumers) {
+      if (!Object.prototype.hasOwnProperty.call(pollConsumers, k)) continue;
+      var c = pollConsumers[k];
+      if (!c || typeof c.run !== 'function') continue;
+      if (typeof c.wants === 'function' && !c.wants()) continue;
+      active.push(c);
+      if (typeof c.jobs === 'function' && c.jobs()) wantJobs = true;
+    }
+    if (!active.length) return;
+    pollSessionsShared(wantJobs, function (list, jobs) {
+      active.forEach(function (c) { try { c.run(list, jobs); } catch (e) {} });
+    });
+  }
+  /* pollSessionsShared 唯一的取数实现：拉清单（可选带 jobs），交给 onDone。
+     onDone 拿到的 list 一定是数组，jobs 可能是 null（没拉 / 拉失败 / 旧服务端）。 */
+  function pollSessionsShared(wantJobs, onDone) {
+    if (!BASE && !TOKEN) return null;
+    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
+    var seq = CONN_SEQ;
+    var pList = fetch(BASE + '/desk/sessions', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .catch(function () { return null; });
+    var pJobs = wantJobs
+      ? fetch(BASE + '/desk/jobs?limit=200', { headers: hdr })
         .then(function (r) { return r.ok ? r.json() : null; })
-        .catch(function () { return null; }) : Promise.resolve(null);
-      Promise.all([pList, pJobs])
-        .then(function (a) {
-          if (seq !== CONN_SEQ) return;   // 响应回来时已经切到另一台桌面了
-          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);
+        .catch(function () { return null; })
+      : Promise.resolve(null);
+    return Promise.all([pList, pJobs])
+      .then(function (a) {
+        if (seq !== CONN_SEQ) return;   // 响应回来时已经切到另一台桌面了
+        var list = Array.isArray(a[0]) ? a[0] : null;
+        if (!list) { notifyWarningOnce(); return; }   // 拉失败：本轮跳过（不清基线、不重绘）
+        /* 记下这一拍：pollOnce（手动/兼容入口）若在 500ms 内醒来可直接复用。 */
+        LAST_FETCH = { at: Date.now(), list: list };
+        /* 通知消费者先吃：它不发请求、不改 DOM，只比状态。 */
+        notifyFromList(list);
+        if (typeof onDone === 'function') onDone(list, a[1] && a[1].jobs);
+      })
+      .catch(function () {});
+  }
+  function startListPoll() {
+    /* ⚠️ 2026-10-26：列表这条**不再自挂定时器**，改为向唯一调度器登记一个消费者
+       （见 tickPoller）。自挂定时器的两个 5s 钟各跑各的，相位必然错开 ——
+       500ms 的同一拍复用挡不住「错开 2 秒」那种撞车，请求数还是翻倍。 */
+    pollConsumers.list = {
+      /* 只在这张页可见时画（不可见就别动 DOM，通知那条照常跑）。 */
+      wants: function () { return !historyEl.hidden && !!TOKEN; },
+      /* jobs 只在列表页可见时才拉：它只影响列表里的「等待中」行，通知不看它。 */
+      jobs: function () { return true; },
+      run: function (list, jobs) {
+        /* 排队 / 运行状态变化也要能触发重绘：旧服务端的排队作业根本不在 /desk/sessions 里；
+           新服务端虽然有登记行（RegisterQueued），但「排队 → 开跑」的占位替换也靠这里
+           把本地那条「等待中」撤掉（见 syncServerJobs）。
+           ⚠️ 清单本身由 tickPoller 统一拉，这里只消费。 */
+        /* 上一帧还是失败态、这次拉通了 → 安静重拉一次把失败块换回列表。
+           不做这个的话，失败态永远不会自己恢复：签名比对里 LAST_SESSIONS 还是旧值，
+           「没变就不重绘」恰好把失败块钉在屏幕上（只能退出重进）。 */
+        if (LIST_FAIL) { LIST_FAIL = false; loadSessions(true); return; }
+        if (sessionSig(list) !== sessionSig(LAST_SESSIONS)) {
+          loadSessions(true);          // 变了才走完整刷新（含标题归纳 / 健康），且不许闪
+          return;
+        }
+        if (serverJobsSig(jobs) !== LAST_JOBS_SIG) loadSessions(true);
+      },
+    };
+    startPoller();
   }
   /* ── 列表加载失败态（2026-10-25）──
      以前是拼一行灰字「读取会话失败：Failed to fetch」，没有任何出路 —— 重试要退出重进，
@@ -4676,8 +5806,34 @@ html[data-theme="dark"] .tabfab__b{
          **之前**：它改的是 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] : []);
+      /* ⚠️ 2026-10-26（用户：「还是在排队」，截图上是一条 state=queued 的会话行，时间 15:06）：
+         那行是**受理时写的排队占位**（core 的 RegisterQueued，run_id = request_id）。
+         正常由服务端在开跑/终结时删掉，但多实例共用同一个作业目录时，占位可能没人清
+         （现场实测：job 早已 done，占位文件还留在登记目录里，mtime 停在受理那一秒）。
+         服务端侧已加周期回收；客户端这里再兜一道 —— 拿到的作业清单里，
+         同一个 request_id 已经是 running / done / failed，就**别再画那条 queued 行**。
+         只在「作业清单里确实有它、且状态不是 queued」时才丢：清单可能被 limit 截断，
+         认不出对应作业的一律保留，宁可多一行也不能把真排队的任务弄丢。 */
+      var sessRows = reconcileQueuedRows(Array.isArray(a[0]) ? a[0] : [], a[4] && a[4].jobs);
+      /* 哪个目录正被谁占着（2026-10-26）。core 的 --sessions 已经把 workspace_locked /
+         lock_holder 给了（见 CLIENT-CONTRACT.md），但**没人用过** —— 于是同目录的新任务
+         只显示「等待中 · 同一空间有任务在跑，它结束后自动开始」，用户不知道在等谁、
+         更不知道要等十分钟才超时。这里把占用者按目录收成一张表，排队行的副标题据此
+         写清「等 PC 上那条『任务模式自动调度方案』」。 */
+      LOCK_BY_WS = {};
+      sessRows.forEach(function (s) {
+        var h = s && s.lock_holder;
+        if (!h || !s.workspace_locked) return;
+        var k = wsKey(s.workspace);
+        if (!k || LOCK_BY_WS[k]) return;   // 一个目录只留第一条（同目录的多条指向同一个持有者）
+        LOCK_BY_WS[k] = {
+          title: String(s.title || s.prompt_head || '').trim(),
+          session: String(s.session_id || ''),
+          source: h.source || '', client: h.client || '', pid: h.pid || 0
+        };
+      });
+      syncServerJobs(a[4] && a[4].jobs, sessRows);
+      renderSessions(sessRows);
       /* 排队任务的接续要等 DW 到手（空间键靠它归一）—— 首次列表到手正是这个时刻。
          幂等：QUEUE_RESTORED 保证只接一次。之前若因 DW 未就绪被跳过，这里补上。 */
       restoreQueue();
@@ -4728,7 +5884,13 @@ html[data-theme="dark"] .tabfab__b{
   var ROOT_DIRS = [];     // 根目录下 magic-* 目录（GET /desk/dirs）
   var CUSTOM_SPACES = [];
   try { CUSTOM_SPACES = normSpaces(JSON.parse(localStorage.getItem('magic.spaces') || '[]')); } catch (e) { CUSTOM_SPACES = []; }
-  /* 自定义空间：每项 = {path, alias}。alias = 用户给这个目录起的**显示名**（可以为空）。
+  /* 空间登记册：每项 = {path, alias, hidden}。
+     ⚠️ 2026-10-26 起它**不再只是「自定义空间」清单** —— 空间有三个来源（根目录 magic-*、
+        自定义、会话产生），以前只有「自定义」那一类能改名/删除，根目录目录与会话产生的空间
+        删不掉也改不了名（用户：「空间都可以修改和删除」）。现在三类统一登记到这一张册子里：
+          · alias  = 用户给这个目录起的**显示名**（可以为空 = 用文件夹名）
+          · hidden = 用户把它从空间列表里移除过（**不删磁盘目录**，只是不再出现在列表里）
+     alias 与 hidden 都以**路径**为键 —— 同一个目录不管从哪个来源冒出来，共用一条登记。
      ⚠️ 显示口径统一走 spaceLabel()：**有别名显示别名，没有就显示最后一级文件夹名，
         永远不显示整条路径** —— /Users/x/work/某某项目 这种一长串路径在手机上一行放不下，
         用户扫一眼也认不出「到底是哪个目录」（用户 2026-10-24：「否则显示最后1级的文件夹不要路径」）。
@@ -4744,12 +5906,19 @@ html[data-theme="dark"] .tabfab__b{
       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 || '') : '' });
+      out.push({
+        path: p,
+        alias: (it && typeof it === 'object') ? String(it.alias || '') : '',
+        /* hidden 只认**真的 true**：老数据里没有这个字段（undefined），
+           不能因为 `!it.hidden` 就把 undefined 当 false 用 —— 那样语义一样但读起来绕。
+           用 === true 是为了「缺字段 = 未隐藏」这件事写在明面上。 */
+        hidden: !!(it && typeof it === 'object' && it.hidden === true)
+      });
     });
     return out;
   }
   function saveSpaces() { try { localStorage.setItem('magic.spaces', JSON.stringify(CUSTOM_SPACES)); } catch (e) {} schedulePushPrefs(); }
-  /* 某个路径是不是自定义空间：是就返回那一项（带 alias），不是返回 null。
+  /* 某个路径在登记册里的那条（带 alias / hidden），没有登记过返回 null。
      ⚠️ 比路径前先归一（分隔符 + 尾斜杠 + 盘符大小写）：用户手输的「/work/proj/」
         与服务端登记的「\work\proj」是同一个空间，别名得认得出。 */
   function customSpaceOf(p) {
@@ -4763,6 +5932,20 @@ html[data-theme="dark"] .tabfab__b{
     if (it && it.alias) return it.alias;
     return basename(p) || String(p || '');
   }
+  /* 这个空间被用户移除过吗（hidden）—— 移除 = 不出现在列表里，磁盘目录原样不动。 */
+  function isHiddenSpace(p) {
+    var it = customSpaceOf(p);
+    return !!(it && it.hidden);
+  }
+  /* 给某个空间**登记一条**（没有就新建），返回那条登记。改名 / 移除都走它，
+     保证「同一个目录只登记一次」。 */
+  function ensureSpaceEntry(p) {
+    var it = customSpaceOf(p);
+    if (it) return it;
+    it = { path: reqNormDir(p), alias: '', hidden: false };
+    CUSTOM_SPACES.push(it);
+    return it;
+  }
   /* 空间候选 = 根目录下的 magic-* + 自定义 + 会话里出现过的 workspace（去重、保序）。
      ⚠️ 去重要按**比较口径**（spaceKey）而不是原字符串：服务端给的是 Windows 原样
         （D:\workspace\x），自定义空间是归一后的（D:/workspace/x）—— 同一个目录会
@@ -4775,6 +5958,8 @@ html[data-theme="dark"] .tabfab__b{
     var seen = {}, out = [];
     function add(p) {
       if (!p) return;
+      /* 被用户移除过的空间不进列表（hidden = 只从列表里拿掉，磁盘目录原样不动）。 */
+      if (isHiddenSpace(p)) return;
       var k = spaceKey(p);
       if (seen[k]) return;
       seen[k] = 1;
@@ -4790,7 +5975,33 @@ html[data-theme="dark"] .tabfab__b{
       if (!isRealSpaceDir(s && s.workspace)) return;
       add(s.workspace);
     });
-    return out;
+    /* ⚠️ 再按**显示名**去重（2026-10-26，用户截图：「magic-stock 出现了两行」）：
+       路径不同但显示名相同，用户看到的是两个一模一样的条目，却指向两个不同的目录 ——
+       「重复的不需要」。
+       根因是**别名撞了真实目录名**：自定义空间 D:/workspace/chan-chart-py 起了别名
+       「magic-stock」，而根目录下真有一个 magic-stock 目录 —— 路径去重抓不到它
+       （spaceKey 不同），但显示名一模一样。
+       留谁？留**显示名 == 目录真名**的那条（也就是真目录）：别名是用户随手起的，
+       真目录名才是客观事实；而且来源优先级也一致（ROOT_DIRS 在前）。
+       两条都是别名（都是用户起的）时留先出现的那条。 */
+    var byLabel = {};
+    var kept = [];
+    out.forEach(function (p) {
+      var label = spaceLabel(p);
+      var isRealName = (label === basename(p));
+      var at = byLabel[label];
+      if (at === undefined) {
+        byLabel[label] = kept.length;
+        kept.push(p);
+        return;
+      }
+      /* 撞名了：已有那条是「真名」就保住它；已有那条是别名而这条是真名 → 换成本条。 */
+      if (!isRealName) return;
+      var prev = kept[at];
+      if (spaceLabel(prev) === basename(prev)) return;   // 已有那条也是真名 → 不换
+      kept[at] = p;
+    });
+    return kept;
   }
   /* 会话里哪些是**顶层会话**（不是别人的子会话）。
      团队模式会把子代理的会话挂到父会话下面去，它们的工作目录是
@@ -4913,12 +6124,30 @@ html[data-theme="dark"] .tabfab__b{
   function cssEscape(v) { return String(v).replace(/["\\]/g, '\\$&'); }
 
   function sidOf(s) { return s.session_id || s.run_id; }
-  function isPinned(s) { return PINNED.indexOf(sidOf(s)) >= 0; }
+  /* ── 手动置顶认「会话」，不认「某一轮的 id」（2026-10-27 用户：
+     「置顶的会话完成也是置顶啊 不要取消」）──
+     一条会话跑着的时候可能只有 run_id —— session_id 是**收尾那一下**才由 core 回填的
+     （见 internal/session 的 Finish）。用户这时钉住，PINNED 里存的就是 run_id；跑完
+     sidOf 换成 session_id，只按字面比就再也对不上 —— 界面上就是「一完成，置顶自己取消了」。
+     团队会话更狠：每轮换一个 session_id，只认一种写法同样会丢。
+     所以判定不看字面，看**这一帧的会话分组**：renderSessions 在选「显示哪一条」之前先建
+     PIN_ROOT（任意 id → 并查集根）与 PIN_NOW（被钉过的组的根），这里按组认人。
+     ⚠️ 与 isAutoPinned 无关：运行中临时置顶仍是**派生**的，跑完照旧归位（2026-10-22 定稿）；
+        这里保证的是**用户亲手钉的那条**不被状态 / id 变化顺手取消。 */
+  var PIN_ROOT = {};   // 这一帧：任意 id（sid / run_id / session_id）→ 所属会话的并查集根
+  var PIN_NOW = {};    // 这一帧：PINNED 命中的那些组的根
+  function isPinned(s) {
+    var id = sidOf(s);
+    if (!id) return false;
+    for (var i = 0; i < PINNED.length; i++) { if (PINNED[i] === id) return true; }
+    var root = PIN_ROOT[id];
+    return !!(root && PIN_NOW[root]);
+  }
   /* 运行中会话**自动临时置顶**（2026-10-22 用户：「运行中的会话自动临时置顶」）：
      判据只看当前是不是在跑（`statusOf === 'run'`），**不写 PINNED、不落 prefs** ——
      跑完下一次 renderSessions 自然归位，用户自己的手动置顶关系一点不动。
      子会话在跑也算：子行默认折叠在父块里，只提子行的话首屏根本看不见，
-     所以把父块一起提到「置顶」段（父行本身不跑时不画图钉，计数徽标会亮运行色，见 sessionRow）。
+     所以把父块一起提到「置顶」段（父行本身不跑时，图标上不挂「临时置顶」角标，计数徽标会亮运行色）。
      ⚠️ 与手动置顶分开判：手动置顶仍只认 PINNED，自动的只在排序 / 分段时叠加。 */
   function isAutoPinned(s) {
     if (!s) return false;
@@ -4971,8 +6200,11 @@ html[data-theme="dark"] .tabfab__b{
       || String(b.updated_at || b.started_at || '').localeCompare(String(a.updated_at || a.started_at || ''));
   }
   function togglePin(s) {
-    var id = sidOf(s), i = PINNED.indexOf(id);
-    if (i >= 0) PINNED.splice(i, 1); else PINNED.unshift(id);
+    var id = sidOf(s), root = PIN_ROOT[id] || '', was = isPinned(s);
+    /* 一次清掉这条会话的**所有**写法（这一轮的 run_id、上一轮的、session_id）：
+       只清字面的话，另一种写法还留在 PINNED 里 —— 刷新一下又变回「已置顶」。 */
+    PINNED = PINNED.filter(function (p) { return p !== id && !(root && PIN_ROOT[p] === root); });
+    if (!was) PINNED.unshift(id);
     savePinned(); renderSessions(LAST_SESSIONS);
   }
   /* 长按会话行 → 浮动菜单：置顶/取消置顶、重命名、删除（对齐截图）。 */
@@ -5130,19 +6362,45 @@ html[data-theme="dark"] .tabfab__b{
      排队标记**只做在图标里**，行尾不再挂角标
      （2026-10-21 用户：「排队标志在会话左边的图标里设计 1 个等待样式即可」）。
      团队标记同理：直接换图形，不再叠小圆角标。 */
-  function sessionIcon(s) {
+  /* AI 判定冲突的「AI」小标（排队图标右下角，2026-10-26 用户：「AI判断的任务需要
+     串行排队的 显示 1 个特殊的标识」）。两条渲染路径共用：本地排队行（pendingRow）
+     与服务端会话行（刷新后本地条目已交出去，只剩登记表那条）。 */
+  /* 「AI 在调度」角标：与置顶图钉同款圆形角标，图标是四芒星（AI 判断的意象）。
+     reason 来自服务端判定结论（auto.reason），拼进 title —— 长按看得到「为什么排队」。 */
+  function aiConflictBadge(reason) {
+    var ai = elSpan('srow__ico-ai');
+    ai.appendChild(svgUse('#i-spark', 11));
+    var why = String(reason || '').trim();
+    ai.title = 'AI 正在调度：' + (why || '判定与运行中的任务冲突，串行等待');
+    ai.setAttribute('aria-label', 'AI 正在调度，串行等待');
+    return ai;
+  }
+  function sessionIcon(s, pinKind) {
     var st = (FUP[sidOf(s)] || []).length ? 'queued' : statusOf(s);
     var ico = elSpan('srow__ico srow__ico--' + st);
     var glyph = (s && s.mode === 'team') ? '#i-team'
       : (String(s && s.source) === 'mobile' ? '#i-phone' : '#i-laptop');
     ico.appendChild(svgUse(glyph, 20));
+    /* 这条排队是 AI 判了冲突（结论由 reconcileQueuedRows 从作业清单挂到 __jobAuto）。 */
+    if (st === 'queued' && s && s.__jobAuto && s.__jobAuto.conflict) ico.appendChild(aiConflictBadge(s.__jobAuto.reason));
+    /* 置顶标记：图标右下角一枚小图钉。
+       manual = 用户手动置顶（PINNED）；auto = 运行中自动临时置顶（跑完归位）。
+       手动置顶必须也画（用户 2026-10：「置顶的更要有」）—— 之前只在自动置顶时画，
+       于是被用户亲手钉住的那几条反倒没有任何标记。 */
+    if (pinKind) {
+      var pin = elSpan('srow__ico-pin' + (pinKind === 'manual' ? ' is-manual' : ''));
+      pin.appendChild(svgUse('#i-pin', 12));
+      pin.title = pinKind === 'manual'
+        ? '已置顶（长按这一行可取消）'
+        : '运行中 · 自动临时置顶（跑完归位）';
+      pin.setAttribute('aria-label', pinKind === 'manual' ? '已置顶' : '运行中自动临时置顶');
+      ico.appendChild(pin);
+    }
     return ico;
   }
-  /* ── 运行中任务的**真实进度** ──
-     步数 = 会话日志里 tool_use 的次数（真实动作数）；时长 = now − started_at。
-     不整表重绘：只就地更新那一行的副标题与时间，避免闪烁/丢滚动位置。 */
-  var RUN_STEPS = {};   // sid → 已执行步数
-  var RUN_CURSOR = {};  // sid → 已读到的事件 seq（null = 还没读过，下次全量）
+  /* ── 运行中任务的**时长** ──
+     时长 = now − started_at（「第 N 步」已去掉：用户定调无意义，不展示）。
+     不整表重绘：只就地更新那一行的时间，避免闪烁/丢滚动位置。 */
   var RUN_ROWS = {};    // sid → 该行的 DOM 引用
   var RUN_TICK = null;
   function pad2(n) { return (n < 10 ? '0' : '') + n; }
@@ -5153,41 +6411,9 @@ html[data-theme="dark"] .tabfab__b{
     var m = Math.floor(sec / 60), ss = sec % 60;
     return m >= 60 ? (Math.floor(m / 60) + ':' + pad2(m % 60) + ':' + pad2(ss)) : (m + ':' + pad2(ss));
   }
-  function runningSub(s, steps) {
+  function runningSub(s) {
     var p = projectOf(s);
-    return (steps ? '运行中 · 第 ' + steps + ' 步' : '运行中') + (p ? ' · ' + p : '');
-  }
-  /* 取「已跑到第几步」。**读过的部分不再重读**（2026-10-20）：
-     原来每 3s 对每条 running 会话拉一次全量 `/messages`，只为数 tool_use 的条数 ——
-     长会话下等于让手机每 3 秒解析一遍几百 MB 的历史（列表页的主要卡顿来源）。
-     现在记一个 seq 游标：首次全量（带 lean=1 让服务端裁掉 snapshot），之后只拉增量，
-     步数在本地累加。游标超前（日志被重置/换会话）时服务端回 snapshotRequired，重置重来。 */
-  function refreshProgress(sid) {
-    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
-    var after = RUN_CURSOR[sid];
-    var url = BASE + '/desk/session/' + encodeURIComponent(sid) +
-      (after == null ? '/messages?lean=1' : '/events?after=' + encodeURIComponent(after) + '&lean=1');
-    fetch(url, { headers: hdr })
-      .then(function (r) { return r.ok ? r.json() : null; })
-      .then(function (d) {
-        if (!d) return;
-        if (d.snapshotRequired) {                     // 游标不可信 → 丢掉重来
-          RUN_CURSOR[sid] = null; RUN_STEPS[sid] = 0;
-          refreshProgress(sid);
-          return;
-        }
-        var n = (after == null) ? 0 : (RUN_STEPS[sid] || 0);
-        var maxSeq = 0;
-        (d.events || []).forEach(function (e) {
-          if ((e.kind || e.type) === 'tool_use') n++;
-          if (e.seq > maxSeq) maxSeq = e.seq;
-        });
-        if (d.lastSeq != null && d.lastSeq > maxSeq) maxSeq = d.lastSeq;
-        RUN_CURSOR[sid] = maxSeq || after || null;
-        RUN_STEPS[sid] = n;
-        var r = RUN_ROWS[sid];
-        if (r && r.subEl) r.subEl.textContent = runningSub(r.s, n);
-      }).catch(function () {});
+    return '运行中' + (p ? ' · ' + p : '');
   }
   function tickRunning() {
     var ids = Object.keys(RUN_ROWS);
@@ -5195,7 +6421,6 @@ html[data-theme="dark"] .tabfab__b{
     ids.forEach(function (sid) {
       var r = RUN_ROWS[sid];
       if (r && r.timeEl) r.timeEl.textContent = elapsedText(r.s);
-      refreshProgress(sid);
     });
   }
   function ensureTicker() {
@@ -5247,14 +6472,18 @@ html[data-theme="dark"] .tabfab__b{
     b.setAttribute('data-sid', sidOf(s));   // ensureTitle 就地改标题时要按 id 找这一行
     var run = statusOf(s) === 'run';
     var queued = statusOf(s) === 'queued';
-    b.appendChild(sessionIcon(s));
+    b.appendChild(sessionIcon(s, isPinned(s) ? 'manual' : (run ? 'auto' : '')));
     var col = elSpan('srow__col');
     col.appendChild(elSpan('srow__t', titleOf(s)));
     var sid = sidOf(s);
-    /* 副标题 = 引擎 · 模型；运行中换成「运行中 · 第 N 步」，排队中说明还在等。
-       进度只改这一个文本节点（RUN_ROWS.subEl 指向它）。 */
-    var subEl = elSpan('srow__s', run ? runningSub(s, RUN_STEPS[sid] || 0)
-      : queued ? '等待中 · 上一个完成后自动开始'
+    /* 副标题 = 引擎 · 模型；运行中换成「运行中 · 空间」，排队中说明还在等。 */
+    var subEl = elSpan('srow__s', run ? runningSub(s)
+      : queued ? ((s.__jobAuto && s.__jobAuto.conflict)
+                  ? '自动 · 串行等待：' + shortReason(s.__jobAuto.reason || '与运行中的任务冲突', 30)
+                : s.__jobState === 'running' ? '启动中 · 引擎已拉起，还没产出第一帧'
+                : TASK_MODE === 'parallel' ? '排队中 · 并行模式下开跑不必等前面'
+                : TASK_MODE === 'auto' ? '等待中 · 自动模式正在调度'
+                : '等待中 · 同一空间有任务在跑，它结束后开始')
       : [s.engine || '', qaModelText(s.model, s.engine)].filter(Boolean).join(' · '));
     col.appendChild(subEl);
     /* 排队与团队标记都不在这里做：两者都做在图标里（见 sessionIcon），行尾不再挂角标。 */
@@ -5293,18 +6522,11 @@ html[data-theme="dark"] .tabfab__b{
       });
       b.appendChild(chip);
     }
-    /* 运行中自动置顶的行带一枚小图钉（手动置顶由「置顶」分段说明，不重复画）：
-       只有**这行自己**在跑才画 —— 父行因某个子会话在跑而被提上来时，行上不画图钉
-       （计数徽标会亮运行色），否则会误读成「父会话在跑」。 */
-    if (run && !isPinned(s)) {
-      var autoPin = elSpan('srow__auto');
-      autoPin.title = '运行中 · 自动临时置顶（跑完自动归位）';
-      autoPin.appendChild(svgUse('#i-pin', 14));
-      b.appendChild(autoPin);
-    }
+    /* 行尾只放时间：运行中自动临时置顶的排序保留，但**不再画图钉**
+       （用户定调：这枚标识不需要）。 */
     var timeEl = elSpan('srow__time', run ? elapsedText(s) : fmtRel(s.updated_at || s.started_at));
     b.appendChild(timeEl);
-    if (run) { RUN_ROWS[sid] = { subEl: subEl, timeEl: timeEl, s: s }; refreshProgress(sid); }
+    if (run) RUN_ROWS[sid] = { timeEl: timeEl, s: s };
     var lp = false, timer = null;
     function cancel() { if (timer) { clearTimeout(timer); timer = null; } }
     b.addEventListener('pointerdown', function () {
@@ -5335,7 +6557,13 @@ html[data-theme="dark"] .tabfab__b{
        找第一个有的，别让空间标题的引擎名因为排队行而消失。 */
     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;
+    /* ⚠️ 除了本地提交的 pendingWait 条目，服务端**受理即登记**的 queued 占位行也要算 ——
+       2026-10-26 实测：自动模式判冲突后那条会话是 state=queued 的登记行，它没有
+       pendingWait 标记，waiting 算成 0 → 空间组按默认规则**折叠** → 排队行（连同刚加的
+       AI 标）全被藏在折叠组里，用户以为「没排队」。有排队就默认展开，组头也能看到计数。 */
+    var waiting = list.filter(function (x) {
+      return x && (x.pendingWait || statusOf(x) === 'queued');
+    }).length;
     tog.appendChild(elSpan('wsrow__l', spaceLabel(key) + (eng ? ' · ' + eng : '')));
     /* 折叠状态也要看得见「这个空间有任务在排队」—— 徽标不随展开/折叠消失。 */
     if (waiting) tog.appendChild(elSpan('wsrow__badge', waiting + ' 等待中'));
@@ -5356,6 +6584,9 @@ html[data-theme="dark"] .tabfab__b{
   function renderSessions(list) {
     LAST_SESSIONS = list || [];
     RUN_ROWS = {};
+    /* 置顶的别名表按帧重建（见 isPinned 上方的说明）：先清空，免得上一帧的分组残留，
+       把一条已被删掉 / 换了 id 的会话仍判成「已置顶」。 */
+    PIN_ROOT = {}; PIN_NOW = {};
     /* 同一 session_id 可能有多轮 run，只留最新一条。 */
     var seen = {}, rows = [];
     LAST_SESSIONS.forEach(function (s) {
@@ -5408,6 +6639,19 @@ html[data-theme="dark"] .tabfab__b{
       var b = KEY2SID[s.parent_run_id || ''] || '';
       if (a && b && a !== b) ufUnion(a, b);
     });
+    /* 置顶别名（第一遍）**必须排在「选显示哪一条」之前**：rowRank 用 isPinned 给组内
+       候选排档，这里还没建别名表的话，钉在 run_id 上的那条会按另一轮的 session_id 判成
+       「没置顶」，组里就选了别人 —— 用户看到的是「钉着的那条不见了」。
+       口径：并查集根相同的记录 = 同一条会话，所以这里把每条记录的各路 id 都指到根。 */
+    PIN_ROOT = {}; PIN_NOW = {};
+    rows.forEach(function (s) {
+      var root = ufFind(sidOf(s));
+      if (!root) return;
+      [sidOf(s), s.run_id, s.session_id].forEach(function (id) {
+        if (id) PIN_ROOT[String(id)] = root;
+      });
+    });
+    PINNED.forEach(function (p) { var r = PIN_ROOT[p]; if (r) PIN_NOW[r] = 1; });
     /* 每组只显示**一条**：人工置顶优先 → 活着（运行中 / 等审批）→ updated_at 新。
        ⚠️ 人工置顶排第一是为了「钉的是哪一轮就显示哪一轮」—— 否则折叠后用户会以为置顶掉了。 */
     function rowRank(s) {
@@ -5445,6 +6689,17 @@ html[data-theme="dark"] .tabfab__b{
       if (s.run_id) GROUP_ALIAS[s.run_id] = own;
       if (s.session_id) GROUP_ALIAS[s.session_id] = own;
     });
+    /* 置顶写法归一（第二遍）：PINNED 里可能还存着**跑之前**的 run_id（那时 session_id
+       还没回填）。现在别名表在手，就地改写成这一组「显示那条」的 id 并去重 ——
+       否则用户下次点「取消置顶」清的是新写法，旧 run_id 还留着，刷新一次又「活」回来。
+       认不出的条目（那条会话这次不在列表里）原样保留：钉过就该一直算钉过。 */
+    var pinNorm = [], pinChanged = false;
+    PINNED.forEach(function (p) {
+      var k = GROUP_ALIAS[p] || p;
+      if (k !== p || pinNorm.indexOf(k) >= 0) pinChanged = true;
+      if (pinNorm.indexOf(k) < 0) pinNorm.push(k);
+    });
+    if (pinChanged) { PINNED = pinNorm; savePinned(); }
     CHILD_OF = {}; CHILD_IDS = {};
     var top = [];
     rows.forEach(function (s) {
@@ -5537,7 +6792,10 @@ html[data-theme="dark"] .tabfab__b{
        真等的（见 gateAsk 的 markWaiting）；但它们在磁盘上已经存在，关 App 也不丢。
        PEND_ROWS = 需要**自己占一行**的排队条目（上面已算好：新任务，或那条会话暂时不在列表里）。 */
     var pendingTasks = PEND_ROWS.filter(function (p) { return !p.explicit; });
-    var tasks = rest.filter(function (s) { return !s.workspace; });
+    /* 被用户移除过的空间，它的会话**回落到「任务」段**（2026-10-26）：删除只是把空间
+       从列表里拿掉，会话本身还在 —— 不能连带把会话也藏了（用户会以为任务丢了）。
+       会话行的副标题仍写着它原来在哪个空间，认得出来。 */
+    var tasks = rest.filter(function (s) { return !s.workspace || isHiddenSpace(s.workspace); });
     if (pinned.length) {
       frag.appendChild(secHead('置顶', pinned.length, false, 'pin'));
       if (!SEC_COLLAPSED.pin) pinned.forEach(function (s) { frag.appendChild(sessionBlock(s)); });
@@ -5566,6 +6824,9 @@ html[data-theme="dark"] .tabfab__b{
     var bySpace = {};
     rest.forEach(function (s) {
       var w = s.workspace; if (!w) return;
+      /* 被用户移除过的空间不再有空间分组（2026-10-26）：它的会话**不丢** ——
+         上面「任务」段会把它们接过去（见 tasks 的过滤）。 */
+      if (isHiddenSpace(w)) return;
       var k = spaceKey(w);
       (bySpace[k] = bySpace[k] || []).push(s);
     });
@@ -5575,6 +6836,7 @@ html[data-theme="dark"] .tabfab__b{
        用 PEND_ROWS 而不是 PEND_VIS：并进原会话行的追问不该再在空间组里插一行。 */
     PEND_ROWS.forEach(function (p) {
       if (!p.explicit || !p.ws) return;
+      if (isHiddenSpace(p.ws)) return;
       var k = spaceKey(p.ws);
       (bySpace[k] = bySpace[k] || []).unshift(p);
     });
@@ -5881,7 +7143,7 @@ html[data-theme="dark"] .tabfab__b{
      组件没挂载时给「沿用默认 / 关闭」，不编造。 */
   function paintRunSettings() {
     var d = document.getElementById('rsDevice');
-    if (d) d.textContent = histSubtitle || '本机';
+    if (d) d.textContent = envName();
     var w = document.getElementById('rsWorkspace');
     if (w) w.textContent = wsLabel();
     var p = document.getElementById('rsPermission');
@@ -5975,6 +7237,47 @@ html[data-theme="dark"] .tabfab__b{
         open 永远不来 → 会话行已经在跑，本地还挂着一条假的「等待中」。现在只要服务端作业
         不再排队、且登记表里确实看得见它，就把本地行撤掉（见 jobLanded）。 */
   var SERVER_ROW_MIN_AGE_MS = 1200;   // 刚提交的别闪一下「等待中」再消失（空闲空间通常 1s 内就开跑）
+  /* 服务端作业的 error 是**拼起来的诊断串**：先一行 stderr 原文，再一行 core 的 JSON。
+     直接塞进副标题（40 字）会把最关键的那半句（「超时（10m0s）」）截掉 —— 实测
+     「未能启动：magic-agent: 同一工作空间已有任务在跑，等待其结束（/ws）… {…」，
+     用户还是不知道发生了什么。所以这里只取 JSON 里的 error/reason，没有才退回第一行。
+     目标：一行说清「为什么失败 + 系统做了什么（等了多久）」。 */
+  function jobHumanReason(raw) {
+    var s = String(raw || '').trim();
+    if (!s) return '服务端启动失败';
+    /* 从后往前找 JSON 行 / 内嵌 {...}：core 的报错总在最后。 */
+    var m = s.match(/\{[\s\S]*\}$/);
+    if (m) {
+      try {
+        var j = JSON.parse(m[0]);
+        var why = String((j && (j.error || j.reason)) || '').trim();
+        if (why) return why;
+      } catch (e) {}
+    }
+    return s.split('\n').map(function (x) { return x.trim(); }).filter(Boolean)[0] || '服务端启动失败';
+  }
+  /* 目录 → 正占着它的那条会话（2026-10-26）。由 loadSessions 从 --sessions 的
+     workspace_locked / lock_holder 填（见那里的说明），只用来把排队行的副标题写具体。 */
+  var LOCK_BY_WS = {};
+  /* 占用者的人话标签：优先用设备形态（用户在手机上操作时最认这个），
+     其次客户端名，都没有就退回 pid。 */
+  function lockHolderLabel(h) {
+    if (!h) return '';
+    var where = h.source === 'mobile' ? '手机' : h.source === 'pc' ? 'PC' : '';
+    if (!where && h.client) where = h.client === 'com.magic.test' ? '掌天瓶' : h.client;
+    var who = where ? where + '上' : '';
+    if (h.title) return who + '那条「' + shortReason(h.title, 18) + '」';
+    if (who) return who + '一条任务';
+    return h.pid ? '进程 ' + h.pid : '';
+  }
+  /* 已经在界面点过重试的服务端失败作业（job id → 1，2026-10-26）。
+     服务端那条 failed 记录会一直留在 /desk/jobs 里（终态不删）；不过滤的话，用户点按
+     重试之后下一拍轮询又把它画回来，看起来像「重试没生效、还多了一条」。只在内存里记：
+     刷新页面后重新显示是可以接受的（那说明它确实还失败着，用户也该再看到一次）。 */
+  var RETRIED_JOBS = {};
+  /* 失败作业在列表里最多留多久（2026-10-26）。见 syncServerJobs 里 failed 分支的说明：
+     只显示近期失败，历史失败不占列表位置。 */
+  var FAILED_ROW_TTL_MS = 30 * 60 * 1000;
   function jobTimeMs(t) {
     if (!t) return 0;
     var d = new Date(String(t));      // 服务端给的是 RFC3339
@@ -5990,8 +7293,74 @@ html[data-theme="dark"] .tabfab__b{
       .map(function (j) { return String(j.id) + ':' + j.state + ':' + (j.position || 0); })
       .sort().join('|');
   }
+  /* 并行模式：把**已经排在服务端队里**、却被当成串行受理的作业就地改成并行。
+     ⚠️ 2026-10-23（用户：「现在是并行模式怎么还在串行等待」，截图上是一条 state=queued 的会话行）：
+       这类作业是旧客户端 / 旧提交路径留下的 —— `fireQueued` 过去不传 serial（服务端 nil 即串行），
+       或者用户在串行模式下排进去之后才切到并行。applyTaskModeToQueued 只在**拨开关的那一刻**
+       推一次；已经切好模式、只是重开 App / 换设备的场景它根本不会跑，于是那些作业会一直在
+       服务端排独占队，直到整条串行队消化完 —— 界面显示并行，行为还是串行。
+       这里每次拿到作业清单就顺手对齐一次（同一 job 只推一次，防刷）：
+         · 只动 queued；running 的 updateSerial 服务端本来也会拒绝（updated=false）；
+         · 推送成功后置 MIRRORED，下一次 loadSessions 拿到 serial=false 就自然不再推。
+     口径与 applyTaskModeToQueued 一致：任务模式是**环境级**设置，同环境排着的作业都跟着走。 */
+  var MODE_MIRRORED = {};
+  function mirrorModeToQueuedJobs(jobs) {
+    /* 只认**明确并行**这一档：自动模式下 queued 作业的 serial 是服务端的判定结论，
+       在这里改成 false 等于把「冲突、该排队」的结论抹掉。 */
+    if (!SERVER_JOBS || !Array.isArray(jobs) || TASK_MODE !== 'parallel') return;
+    var hdr = { 'Content-Type': 'application/json' };
+    if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
+    jobs.forEach(function (j) {
+      if (!j || !j.id || j.state !== 'queued' || j.serial === false) return;
+      if (MODE_MIRRORED[j.id]) return;
+      MODE_MIRRORED[j.id] = 1;
+      fetch(BASE + '/desk/jobs/' + encodeURIComponent(j.id) + '/update', { method: 'POST', headers: hdr,
+        body: JSON.stringify({ serial: false }) })
+        /* 服务端放行后调度器会立刻重排（jobs.go 的 updateSerial 末尾 q.signal()），
+           这里拉一次清单让「排队中」那行当场变成运行中，不必等下一次 5s 轮询。 */
+        .then(function (r) { return r.ok ? r.json() : null; })
+        .then(function (out) {
+          if (out && out.updated && typeof loadSessions === 'function') loadSessions(true);
+        })
+        .catch(function () { delete MODE_MIRRORED[j.id]; });
+    });
+  }
+  /* 用**作业清单**校准「排队占位」那一行（见 loadSessions 的注释）。占位行是受理那一刻
+     写进登记表的（run_id = request_id），它的 state 恒为 queued，**不会自己变**；
+     作业真开跑了、甚至早早收尾了，这一行还挂着「排队中」——用户看到的就是「还在排队」。
+     校准三档（只对 state=queued 的行，其余原样）：
+       · 作业已终结（done/failed/cancelled/expired）→ 丢掉：它的真实会话记录另有一行；
+       · 作业 running → 保留，但标 __jobState=running，副标题改说「启动中」——
+         这时 engine 进程已经起来了，只是还没登记/还没吐第一帧，说「排队」是错的；
+       · 作业还 queued（或清单里认不出它）→ 原样保留。
+     run_id 与作业的 request_id / job id 是同一套键（queuedSessionID），所以直接对得上。 */
+  function reconcileQueuedRows(list, jobs) {
+    if (!Array.isArray(list) || !Array.isArray(jobs) || !jobs.length) return list;
+    /* 存**整个作业**而不只是状态：排队行要显示「为什么等」（auto.conflict/reason），
+       刷新后本地条目已经交出去了，这些信息只能从作业清单这里挂到会话行上。 */
+    var byId = {};
+    jobs.forEach(function (j) {
+      if (!j || !j.state) return;
+      if (j.request_id) byId[String(j.request_id)] = j;
+      if (j.id) byId[String(j.id)] = j;
+    });
+    var out = [];
+    list.forEach(function (s) {
+      if (!s) return;
+      if (statusOf(s) !== 'queued') { out.push(s); return; }
+      var jv = byId[String(sidOf(s) || '')];
+      if (jv && jv.auto) s.__jobAuto = jv.auto;   // 直接挂在行对象上，sessionRow/sessionIcon 读它
+      var st = jv && jv.state;
+      if (!st || st === 'queued') { out.push(s); return; }
+      /* judging（自动判定中，2026-10-26）与 running 一样是「活着」：占位行不能删。 */
+      if (st === 'running' || st === 'judging') { s.__jobState = 'running'; out.push(s); return; }
+      /* 其余都是终态：这一行是陈迹（真实记录由 core 写过，或被删掉了）。 */
+    });
+    return out;
+  }
   function syncServerJobs(jobs, sessions) {
     if (!SERVER_JOBS || !Array.isArray(jobs)) return;
+    mirrorModeToQueuedJobs(jobs);
     var now = Date.now();
     var localOf = {};
     PENDING.forEach(function (p) {
@@ -6026,6 +7395,12 @@ html[data-theme="dark"] .tabfab__b{
              · 真的跑起来了 → 撤掉本地行（会话行接手显示）；
              · 没跑起来就终结（failed / expired / cancelled）→ 标成可重试的「未能启动」，
                绝不静默消失（与 fireQueued 的判据同一口径）。 */
+        /* 自动判定中（2026-10-26）：≤2.5s 的中间态，**保留本地「等待中」行别动** ——
+           按下面「非排队态」那套处理会把它当终态删掉/标失败，用户会看到行闪一下消失。 */
+        if (j.state === 'judging') {
+          if (j.auto) { lp.auto = j.auto; touched = true; }
+          return;
+        }
         if (j.state !== 'queued') {
           if (jobLanded(j, sessions)) { lp.gone = true; dead.push(lp.id); return; }
           if (j.state === 'running') return;            // 登记表还没落盘：下一拍再看
@@ -6045,6 +7420,41 @@ html[data-theme="dark"] .tabfab__b{
           return;
         }
         if (lp.hide) { lp.hide = false; touched = true; }
+        /* 判定结论跟着作业走：排队行的副标题要说明「为什么在排队」（自动 · 与谁冲突）。 */
+        if (j.auto) {
+          if (JSON.stringify(lp.auto || null) !== JSON.stringify(j.auto)) { lp.auto = j.auto; touched = true; }
+        }
+        return;
+      }
+      /* ⚠️ 2026-10-26（用户：「现在无法新建任务了 直接任务消失了」）：
+         **failed 必须留一行**。从前这里对非 queued 一律 return，界面上什么都不画 ——
+         可服务端明明有这条作业、也写了真实原因（这次是「同一工作空间已有任务在跑，
+         等待其结束…超时（10m0s）」）。用户看到的是「点了发送，任务凭空没了」，
+         既不知道在排队、也不知道排了十分钟才失败，更没法重试。
+         只有 cancelled / expired 才该安静消失：那是用户主动取消 / 排队过夜过期，
+         本来就不该再占一个位置。
+         RETRIED_JOBS：这条已经从界面点过重试了 —— 服务端那条 failed 作业还挂在
+         /desk/jobs 里，不过滤的话下一拍又画回来（重试刚点的行会闪成两条）。
+         FAILED_ROW_TTL_MS：只给**近期**的失败留位。作业文件名不是「跑完就删」的
+         （实测这台机器上累计 31 条 failed，最老的隔了一天多），全画出来会把列表塞满
+         历史垃圾，用户反而找不到自己刚发的那条。30 分钟内够覆盖「我发了、它没了」
+         这个真实场景；更老的去「最近会话」里找（失败的 core 若真起来过会有记录）。 */
+      if (j.state === 'failed' && !RETRIED_JOBS[j.id] && !jobLanded(j, sessions)
+          && (now - jobTimeMs(j.updated_at || j.created_at) < FAILED_ROW_TTL_MS)) {
+        rows.push({
+          id: 'srv-' + j.id + '-failed', fromJob: true, job: j.id, requestId: j.request_id || '',
+          ws: wsKey(j.explicit_workspace ? j.workspace : ''),
+          w: j.explicit_workspace ? j.workspace : '',
+          explicit: !!j.explicit_workspace, pendingWait: true, hide: false, owner: 'host',
+          session: j.session || '', prompt: j.prompt || '', engine: j.engine || '',
+          model: j.model || '', team: j.team || null, hosted: !!j.hosted,
+          /* 重试要原样还原用户的这些选择，否则第二次跑会用默认权限 / 档位。 */
+          permission: j.permission || '', reasoning: j.reasoning || '',
+          attachments: (j.attachments || []).slice(),
+          atts: [], pos: 0, at: jobTimeMs(j.created_at), auto: j.auto || null,
+          /* stalled：pendingRow 据此画红字 + 给「点按重试」（与本地下发失败同一套画法）。 */
+          stalled: true, stalledReason: jobHumanReason(j.error)
+        });
         return;
       }
       if (j.state !== 'queued') return;
@@ -6063,7 +7473,7 @@ html[data-theme="dark"] .tabfab__b{
         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)
+        pos: j.position || 0, at: jobTimeMs(j.created_at), auto: j.auto || null
       });
     });
     rows.sort(function (a, b) { return (a.at || 0) - (b.at || 0); });   // FIFO，与队列顺序一致
@@ -6199,8 +7609,9 @@ html[data-theme="dark"] .tabfab__b{
       var pend = pendingOf(p.prompt);
       var rid = (pend && pend.id) || ('q' + Date.now() + '-' + Math.floor(Math.random() * 100000));
       p.request_id = rid;
-      /* 串行模式由用户选；并行模式显式传 false，服务端仍会套全局并发上限。 */
-      if (p.serial === undefined) p.serial = (TASK_MODE === 'serial');
+      /* 模式统一由 applyTaskModeToPayload 翻成 mode/serial（自动模式还要带判定引擎）。
+         调用方已经显式指定 mode/serial 的（内部重发路径）不覆盖。 */
+      if (p.mode === undefined && p.serial === undefined) applyTaskModeToPayload(p);
       var hs = h || {};
       var onOpen = hs.onOpen, onEvent = hs.onEvent, onEnd = hs.onEnd, onErr = hs.onError;
       if (pend && !pend.gone) {
@@ -6212,6 +7623,9 @@ html[data-theme="dark"] .tabfab__b{
         if (ev && ev.state === 'queued' && pend && !pend.gone) {
           if (ev.job) pend.job = ev.job;
           pend.pos = ev.position || 0;
+          /* 自动模式：判定结论随 queued 一起回来（服务端 handleAsk 的 auto 字段，只增）。
+             有它就写进本地行，副标题才能说「与谁冲突 / 判无冲突」，而不是干巴巴「等待中」。 */
+          if (ev.auto) pend.auto = ev.auto;
           if (pend.hide) { pend.hide = false; renderSessions(LAST_SESSIONS); }
           if (typeof pend.queuedCb === 'function') { try { pend.queuedCb(true); } catch (e) {} }
         }
@@ -6541,6 +7955,9 @@ html[data-theme="dark"] .tabfab__b{
      本地串行门（!SERVER_JOBS）不用管：waitForSlot 每一拍都看 TASK_MODE，最多 3s 自己生效。 */
   function applyTaskModeToQueued(v) {
     if (!SERVER_JOBS) return;
+    /* 切到「自动」不回溯已排队的作业（用户 2026-10-26：「不需要排队 60 秒后重新判定」）：
+       它们保留判定当时的结论，只有这之后的新提交按自动模式走。 */
+    if (v === 'auto') return;
     var serial = (v === 'serial');
     PENDING.forEach(function (p) {
       if (!p || p.gone || p.cancelled) return;
@@ -6642,7 +8059,7 @@ html[data-theme="dark"] .tabfab__b{
      失败则保留并标「未能启动」，下次连上由 restoreQueue 再试（request_id 不变 → 幂等）。 */
   function submitQueuedJob(p) {
     if (!connected()) return Promise.resolve(false);
-    var body = { engine: p.engine, prompt: p.prompt, request_id: p.id, serial: (TASK_MODE === 'serial') };
+    var body = applyTaskModeToPayload({ engine: p.engine, prompt: p.prompt, request_id: p.id });
     if (p.model) body.model = p.model;
     if (p.w) body.workspace = p.w;
     if (p.session) body.session = p.session;
@@ -6680,13 +8097,26 @@ html[data-theme="dark"] .tabfab__b{
   }
   function enqueueDispatch(p) {
     var ws = wsKey(p.w);
-    var q = serialQ(ws);
     /* 重新尝试（用户点「未能启动」那条）：先把红字连原因一起摘掉，回到正常的排队态。 */
     if (p.stalled) { p.stalled = false; p.stalledReason = ''; renderSessions(LAST_SESSIONS); }
-    var mine = q.tail.then(function () { return waitForSlot(ws, q); })
-      /* 同一条会话同时只能跑一轮：宿主下发的「追问」必须等这一轮真的收尾。
-         并行模式（waitForSlot 直接放行）下尤其重要 —— 否则新进程和还在跑的那一轮
-         会同时往同一份会话日志里写，正文与思考区交错，是最难查的一类脏数据。 */
+    /* ⚠️ 2026-10-23（用户：「现在是并行模式怎么还在串行等待」）：
+       旧实现不管哪种模式都把这一条挂到 `q.tail` 上 —— 并行模式下 waitForSlot 当场放行，
+       但 q.tail 的串行**链**还在：上一条要等 onOpen（HTTP 往返）才 resolve，甚至要再等
+       fireQueued 的验收（最长 LAND_TIMEOUT_MS），于是后一条明明能并行，却仍在串行排队。
+       现在按模式分开：
+         · 并行：不碰 q.tail（空间级排队只在串行模式下有意义），所有**不同会话**的任务同时开跑；
+         · 串行：照旧进空间 FIFO，队首才能检查（见 waitForSlot 的注释）。
+       ⚠️ 两种模式共有的**会话级**闸门必须留：同一条会话同时只能跑一轮，
+         否则两个进程会同时往同一份会话日志里写，正文与思考区交错，是最难查的一类脏数据。 */
+    var gate;
+    if (TASK_MODE === 'serial') {
+      var q = serialQ(ws);
+      gate = q.tail.then(function () { return waitForSlot(ws, q); });
+      q.tail = gate.catch(function () { return false; });   // 出错也不能让后面永久挂起
+    } else {
+      gate = Promise.resolve(true);
+    }
+    return gate
       .then(function () { return waitSessionIdle(p.session); })
       .then(function () {
         /* 断线 / 还没配对：**留在队列里**，等下次连上再发 —— 不能当成「已下发」删掉。 */
@@ -6696,14 +8126,16 @@ html[data-theme="dark"] .tabfab__b{
         if (p.owner !== 'host') return false;
         p.dispatching = true;        // 已交给 fireQueued：此后不许组件再接管（防双发）
         return fireQueued(p);
-      });
-    q.tail = mine.catch(function () { return false; });
-    return mine.then(function (sent) {
-      if (!sent) return;   // 没落盘：留在队列里（stalled），不删
-      dropPending(p.id);
-      /* 条目刚删掉、会话行还没被 5s 轮询拉到 —— 立刻刷一次，避免列表出现空档。 */
-      if (typeof loadSessions === 'function') loadSessions(true);
-    }, function () { /* 没发出去：保留，下次连上重试 */ });
+      })
+      /* ⚠️ 故意**不**把 fireQueued 挂回 q.tail（旧写法 `q.tail = mine…`）：那是并行仍串行的
+         根因 —— 后一条要等前一条「真正开跑并被登记表看见」才轮到。串行模式的排队已经在
+         waitForSlot 的 held 占位里表达，这里只负责发。 */
+      .then(function (sent) {
+        if (!sent) return;   // 没落盘：留在队列里（stalled），不删
+        dropPending(p.id);
+        /* 条目刚删掉、会话行还没被 5s 轮询拉到 —— 立刻刷一次，避免列表出现空档。 */
+        if (typeof loadSessions === 'function') loadSessions(true);
+      }, function () { /* 没发出去：保留，下次连上重试 */ });
   }
   /* 真正下发一条排队任务：只发、不收画面（事件进会话日志，点开会话可回放）。
      ⚠️ **收到 open 不等于任务跑起来了** —— open 只说明连上了 `/desk/ask`，core 可能
@@ -6724,6 +8156,14 @@ html[data-theme="dark"] .tabfab__b{
        ② 列表侧 syncServerJobs 靠它把本地「等待中」和 /desk/jobs 里的同一作业认成
           一行 —— 不带的话，恢复队列重发时本地行 + 服务端快照行会各画一条。 */
     if (p.id) payload.request_id = p.id;
+    /* ⚠️ 2026-10-23（用户：「现在是并行模式怎么还在串行等待」，截图上是一条 state=queued 的会话行）：
+       服务端 `askRequest.Serial` 的语义是 **nil = 串行**（jobs.go: `serial := true` 只有当
+       `req.Serial != nil` 时才被覆盖）。这条重发路径原先一个字节都不传 → 服务端按串行处理 →
+       同一 workspace 里前一条在跑，这一条就一直 queued，而客户端显示的还是「并行模式」。
+       这是「客户端以为并行、服务端仍在串行」的唯一一处漏网：gateAsk 走 /desk/ask 有
+       wrapTransportForJobs 补 serial，restoreQueue 走 submitQueuedJob 也补了，只有这里漏。
+       并行模式显式传 false（服务端仍会套全局并发上限，见 jobs.go 的 parallelHeadroom）。 */
+    applyTaskModeToPayload(payload);
     if (p.model) payload.model = p.model;
     if (p.w) payload.workspace = p.w;
     /* 带上原会话 id 才是「追问」；不带就是新起一段会话（见 addPending 里 session 的注释）。 */
@@ -6738,7 +8178,22 @@ html[data-theme="dark"] .tabfab__b{
     if (p.hosted) payload.hosted = true;
     if (p.attachments && p.attachments.length) payload.attachments = p.attachments;
     return new Promise(function (resolve) {
-      var done = false, handle = null, t0 = Date.now();
+      var done = false, handle = null, t0 = Date.now(), armed = false;
+      /* ── 不在会话页里：发出去就够了，验收交给登记表 ──
+         ⚠️ 2026-10-23（「现在是并行模式怎么还在串行等待」）：宿主下发本来只「发、不收画面」，
+         但这里紧跟 onOpen 就 cancel —— 用户在列表页 / 已经离开会话页时，open 帧永远到不了，
+         验收函数一次都不会跑，条目挂着「等待中」直到 20s 超时判「未能启动」。
+         更糟的是：异步的收口让列表上出现「一条在跑、另一条还在等」，并行模式下看起来就是串行。
+         现在：open 到了就先起验收（arm），再掐掉这条没人看的长连接；掐过之后只按登记表判
+         （见 byRegistryOnly），确认不到由 LAND_TIMEOUT_MS 收口。 */
+      function arm() {
+        if (armed) return;
+        armed = true;
+        try { if (handle && handle.cancel) handle.cancel(); } catch (e) {}
+        seenInRegistry(0);
+      }
+      /* 记录起点：pollOnce 的对账（reconcileQueued）靠它认「t0 之后新出现的记录」。 */
+      p.t0 = t0;
       /* why = 失败原因（人话）。以前判失败只留一个布尔，用户只能看到「未能启动」四个字，
          无从判断是路由配错、core 崩了还是隧道断了（2026-10-21：「未能启动 为什么」）。 */
       var why = '';
@@ -6762,17 +8217,13 @@ html[data-theme="dark"] .tabfab__b{
          优先取里面的 error/reason 当人话；解析不了就退回最后一行原文。
          比「退出码 2」对用户有用得多。 */
       function endReason(code, ev) {
-        var lines = String((ev && ev.stderr) || '').split('\n')
-          .map(function (x) { return x.trim(); }).filter(Boolean);
-        for (var i = lines.length - 1; i >= 0; i--) {
-          var t = lines[i];
-          if (t.charAt(0) === '{') {
-            try {
-              var j = JSON.parse(t);
-              if (j && (j.error || j.reason)) return String(j.error || j.reason);
-            } catch (e) {}
-          }
-          return t;
+        /* 与作业快照那条路径共用同一个提炼函数（见 jobHumanReason）——
+           两条路各写一份的话，同一次失败在「本地下发」和「服务端快照」两种呈现下
+           会给出措辞不同的原因，用户会以为踩了两个不同的坑。 */
+        var s = String((ev && ev.stderr) || '').trim();
+        if (s) {
+          var why = jobHumanReason(s);
+          if (why && why !== '服务端启动失败') return why;
         }
         return code ? 'core 退出码 ' + code : '';
       }
@@ -6785,10 +8236,14 @@ html[data-theme="dark"] .tabfab__b{
         /* 只增不减：onError 之后再来的 onEnd(null) 不能把宽限期压回 0，否则刚许的 4s 白给。 */
         if (typeof graceMs === 'number' && graceMs > grace) grace = graceMs;
         var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
+        /* 兜底验收：arm() 之后掐了流，seenAt 就再也不会更新 —— 不能再拿「流收尾了 + 宽限已过」
+           当失败判据（那是「确认这条路走完了」，不是「它没起来」）。改为：掐过流 / 曾经离开了
+           会话页（LEAVE_CONV_AT 晚于 t0）时，只按会话登记表判，确认不到由 LAND_TIMEOUT_MS 收口。 */
+        var byRegistryOnly = armed || LEAVE_CONV_AT > t0;
         function again() {
           if (done) return;
           var now = Date.now();
-          if (seenAt && now - seenAt >= grace) { fin(false); return; }
+          if (!byRegistryOnly && seenAt && now - seenAt >= grace) { fin(false); return; }
           if (now - t0 >= LAND_TIMEOUT_MS) {
             why = why || '20 秒内没有出现在会话登记表（core 没起来或请求没到服务端）';
             fin(false);
@@ -6800,9 +8255,12 @@ html[data-theme="dark"] .tabfab__b{
           .then(function (r) { return r.ok ? r.json() : null; })
           .then(function (list) {
             if (done) return;
+            /* ⚠️ 新任务只认**自己的** t0：并行模式下同一空间可能有好几条同时发出，
+               「任意一条在跑」不等于「这一条起来了」—— 认早了它的记录还没出现就被删行，
+               用户点开会话看到的是空白。容差 2s 在 startedAfter 里。 */
             var seen = Array.isArray(list) && list.some(function (s) {
               if (wsOf(s) !== wsKey(p.w)) return false;
-              if (p.session) return String(sidOf(s) || '') === String(p.session);
+              if (p.session) return String(sidOf(s) || '') === String(p.session) || startedAfter(s, t0);
               return startedAfter(s, t0);
             });
             if (seen) fin(true); else again();
@@ -6811,7 +8269,9 @@ html[data-theme="dark"] .tabfab__b{
       }
       try {
         handle = transport.ask(payload, {
-          onOpen: function () { seenInRegistry(0); },
+          /* open 到了就交验收（arm：先起验收，再掐掉这条没人看的长连接）。
+             不管这一条是不是在会话页里发的 —— 判据只看登记表，不看流还在不在。 */
+          onOpen: function () { arm(); },
           /* 事件里一旦带出 session_id，说明 core 已经跑起来并登记了 —— 不必再查表。 */
           onEvent: function (ev) { if (ev && ev.session_id) fin(true); },
           /* code 非空 = 这一轮以失败收尾；若登记表里也没有它，就是没跑起来。
@@ -6843,6 +8303,35 @@ html[data-theme="dark"] .tabfab__b{
     });
   }
 
+  /* ── 宿主下发的对账（2026-10-23「并行模式还在串行等待」的第二个口子）──
+     宿主这条（fireQueued）只想「发、不看画面」，验收靠 open 帧 —— 但那帧要等服务端
+     真把 SSE 建起来。用户在列表页时，或流被环境层立刻掐掉时，open 可能**永远不来**：
+     条目就卡在「等待中」，要等 20s 超时才收口；那 20s 里列表看着就像还在串行排队。
+     这里不修任何时序细节，只做**对账**：每一拍拿到登记表，凡是已下发、还没记账的条目，
+     只要该空间/该会话里出现了 t0 之后开始、或此刻还在跑的记录，就当场认它「开跑了」。 */
+  function reconcileQueued(list) {
+    var hit = false;
+    PENDING.forEach(function (p) {
+      if (!p || p.gone || p.owner !== 'host' || !p.dispatching || p.claimed || !p.t0) return;
+      var ws = wsKey(p.w);
+      var seen = list.some(function (s) {
+        if (p.session) {
+          var sid = String(sidOf(s) || '');
+          return sid === String(p.session) && (serialBusy(s) || startedAfter(s, p.t0));
+        }
+        return wsOf(s) === ws && (serialBusy(s) || startedAfter(s, p.t0));
+      });
+      if (!seen) return;
+      p.claimed = true;
+      hit = true;
+      /* 与 fireQueued 的成功收口同一动作：删行 + 立刻刷一次列表（避免 5s 轮询前的空档）。
+         fireQueued 自己的验收随后也会认租它（服务端已开跑 → 登记表一定有记录），
+         p.gone 之后那边的 dropPending / stalled 都是空操作。 */
+      dropPending(p.id);
+    });
+    if (hit && typeof loadSessions === 'function') loadSessions(true);
+  }
+
   /* 等待中任务的列表行（不可点开，纯状态展示）。
      带 session 的是**历史会话的追问**（串行门对追问一视同仁，见 gateAsk）：
      副标题说清楚「追问」二字，否则用户会以为自己在原会话里排队，列表上却凭空多出
@@ -6853,6 +8342,9 @@ html[data-theme="dark"] .tabfab__b{
     var ico = elSpan('srow__ico srow__ico--queued');
     /* 团队任务排队时也用双人图形，别先闪一下电脑再换（与 sessionIcon 同一规则）。 */
     ico.appendChild(svgUse(p.team ? '#i-team' : '#i-laptop', 20));
+    /* AI 判定「与运行中的任务冲突，必须串行」才挂标；并行模式下没轮到（等槽位）、
+       自动判定降级为并行、stalled 重试行都不挂 —— 那个标只代表「AI 判了冲突」。 */
+    if (p.auto && p.auto.conflict && !p.stalled) ico.appendChild(aiConflictBadge(p.auto.reason));
     b.appendChild(ico);
     var col = elSpan('srow__col');
     col.appendChild(elSpan('srow__t', String(p.prompt || '新任务').slice(0, 40)));
@@ -6862,8 +8354,27 @@ html[data-theme="dark"] .tabfab__b{
        后面拼上**真实原因**（end 帧 stderr / HTTP 正文 / 超时），否则用户只知道失败、
        不知道是路由配错还是服务没起（2026-10-21：「未能启动 为什么」）。 */
     var reason = p.stalled ? String(p.stalledReason || '').trim() : '';
+    /* ⚠️ 2026-10-23（用户：「现在是并行模式怎么还在串行等待」）：串行模式下这条文案是对的；
+       并行模式还排在队里，**不是**串行门在挡，而是三者之一（见下面三支）——
+       写成「上一个完成后自动开始」等于把真实原因藏起来，用户就会以为模式开关没生效。 */
+    /* 自动模式的排队行要说清「为什么等」：判冲突时把冲突对象/文件直接写出来，
+       否则用户只会看到一条「等待中」，以为模式开关又没生效（2026-10-24 那次报障的观感）。 */
+    var auto = p.auto || null;
+    /* 这个目录正被谁占着（2026-10-26）：「同一空间有任务在跑」只说了一半 ——
+       用户没法判断该等、该去停哪条、还是该换个空间发。core 已经把占用者身份
+       随 --sessions 给了（workspace_locked / lock_holder），这里直接用；
+       老 core 没有这两个字段 → LOCK_BY_WS 为空 → 文案自动退回原来那句。 */
+    var holder = LOCK_BY_WS[p.ws] || null;
+    var waitWho = holder ? lockHolderLabel(holder) : '';
     var text = p.stalled ? '未能启动' + (reason ? '：' + shortReason(reason, 40) : '') + ' · 点按重试'
-             : (p.session ? '追问排队中 · ' : '等待中 · ') + '上一个完成后自动开始';
+             : p.session ? '追问排队中 · 同一会话上一轮结束后自动发送'
+             : (auto && auto.conflict) ? '自动 · 串行等待：' + shortReason(auto.reason || '与运行中的任务冲突', 34)
+             : (auto && auto.by === 'model') ? '等待中 · 自动判定无冲突，正在开跑'
+             : (auto && auto.by === 'undecided') ? '等待中 · 自动判定未完成，按并行放行'
+             : TASK_MODE === 'auto' ? '等待中 · 自动模式正在调度' + (waitWho ? '（' + waitWho + '占着这个目录）' : '')
+             : TASK_MODE !== 'serial' ? '等待中 · 正在开跑（并行模式：不必等前面的任务）'
+             : waitWho ? '等待中 · 等 ' + waitWho + '结束'
+             : '等待中 · 同一空间有任务在跑，它结束后自动开始';
     sub.appendChild(elSpan('srow__stext', text));
     col.appendChild(sub);
     b.appendChild(col);
@@ -6874,6 +8385,24 @@ html[data-theme="dark"] .tabfab__b{
       b.onclick = function () {
         if (b.dataset.busy === '1') return;
         b.dataset.busy = '1';
+        /* 服务端那条失败作业（fromJob）点重试后要记住它，否则下一拍轮询又画回来。 */
+        if (p.fromJob && p.job) RETRIED_JOBS[p.job] = 1;
+        /* id 要换一个新的：服务端按 request_id 幂等 —— 沿用旧 id 会直接拿回那条
+           failed 作业（submitAsk 命中 byReq 就返回旧的），用户点了重试却毫无动静。
+           所以这里先摘掉旧条目、用新 id 重建一条再下发。 */
+        if (p.fromJob) {
+          var retry = {
+            ws: p.ws, w: p.w, explicit: p.explicit, session: p.session,
+            prompt: p.prompt, engine: p.engine, model: p.model,
+            permission: p.permission || '', reasoning: p.reasoning || '',
+            team: p.team || null, hosted: !!p.hosted,
+            attachments: (p.attachments || []).slice(), atts: (p.atts || []).slice(),
+            owner: 'host'
+          };
+          dropPending(p.id);
+          enqueueDispatch(addPending(retry.ws, retry, false));
+          return;
+        }
         enqueueDispatch(p);
       };
     }
@@ -7188,6 +8717,217 @@ html[data-theme="dark"] .tabfab__b{
     toast('当前没有可用的系统通知通道，已改用应用内提示');
     return Promise.resolve('toast');
   }
+  /* ══════════ 飞书推送（我的 → 飞书推送）══════════
+     2026-10-26 用户：「另增加飞书绑定支持登录后推送通知」。
+     **为什么要有它**：手机端系统通知（上面那一整套）只在页面开着、5 秒轮询在跑、
+     还在同一网络里才响。锁屏 / 切后台 / 人不在 Wi-Fi 上 = 什么都收不到。
+     飞书推送把**桌面端**变成推送源：任务完成 / 待确认时，桌面端用飞书机器人
+     往用户本人推一张卡片，人在飞书里就能看见。
+
+     **绑定 = 两步**（对齐「登录」）：
+       ① 点「获取绑定码」→ POST /desk/feishu/code 拿 6 位码（10 分钟有效）；
+       ② 在飞书里把码发给我们发给你的机器人，再从机器人收到的卡片里把
+          「我的 open_id」填进来 → POST /desk/feishu/bind。
+     为什么不直接让手机自己调飞书接口拿 open_id：远程页（/m/）里没有飞书登录态，
+     拿不到用户身份；而**桌面端**手里有应用凭据（app_id/app_secret），
+     open_id 只要来路可信（绑定码只发给了用户自己）就够定位「推给谁」。
+     绑定码只认发起者的 10 分钟窗口、错码不退让、用过即废 —— 别人猜不到也抢不走。
+
+     状态一律以 GET /desk/feishu 为准（服务端宣布什么就显示什么），
+     本页只缓存最后一次结果给上一页那行「飞书推送」用。 */
+  var FEISHU_CACHE = null;
+  function feishuApi(method, action, body) {
+    if (!BASE && !TOKEN) return Promise.reject(new Error('还没连接桌面端'));
+    var hdr = { 'Content-Type': 'application/json' };
+    if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
+    var opt = { method: method, headers: hdr };
+    if (body != null) opt.body = JSON.stringify(body);
+    return fetch(BASE + '/desk/feishu' + (action ? '/' + action : ''), opt).then(function (r) {
+      return r.json().catch(function () { return {}; }).then(function (j) {
+        if (!r.ok) {
+          /* 老桌面端没有这条路由：404 的 body 不是我们的 {error} 形状，给一句能落地的提示。 */
+          if (r.status === 404) throw new Error('桌面端版本过旧，没有飞书推送接口（升级 magic-agent 后重启服务）');
+          throw new Error((j && j.error) || ('HTTP ' + r.status));
+        }
+        return j;
+      });
+    });
+  }
+  /* 「我的」那行「飞书推送」的值：未绑定 / 已绑定 · 已开启 / 已绑定 · 已关闭。 */
+  function feishuLabel(st) {
+    if (!st) return '—';
+    if (!st.bound) return st.mode === 'webhook' ? '未绑定' : '未绑定 · 未配置通道';
+    return st.enabled ? '已开启' : '已关闭';
+  }
+  function paintFeishuSummary(st) {
+    var el = document.getElementById('feishuSummary');
+    if (el) el.textContent = feishuLabel(st);
+  }
+  function refreshFeishuSummary() {
+    if (FEISHU_CACHE) paintFeishuSummary(FEISHU_CACHE);
+    if (!BASE && !TOKEN) return;
+    feishuApi('GET').then(function (st) {
+      FEISHU_CACHE = st;
+      paintFeishuSummary(st);
+    }).catch(function () { /* 拉不到就保持原样，别把「—」当成未绑定 */ });
+  }
+  function feishuSub(body, text, opts) {
+    var d = elSpan('pick__d', text);
+    d.style.display = 'block'; d.style.margin = '0 0 8px'; d.style.textAlign = 'left';
+    d.style.lineHeight = '1.55';
+    if (opts && opts.error) d.style.color = 'var(--error-text)';
+    body.appendChild(d);
+    return d;
+  }
+  function feishuBtn(body, label, onClick, opts) {
+    var b = hEl('button', 'btn' + ((opts && opts.filled) ? ' btn--filled' : ''), label);
+    b.type = 'button';
+    b.style.marginTop = '6px';
+    /* 抽屉里的按钮是**整行**的（.btn 默认撑满）；这里塞在列表流里，会被
+       `.setrow{text-align:left}` 这类继承带成左对齐，读起来像一行正文。
+       显式居中 + 左右留一点边，让它一眼是「可以点的按钮」。 */
+    if (opts && opts.danger) { b.style.color = 'var(--error-text)'; }
+    if (opts && opts.disabled) { b.disabled = true; b.style.opacity = '.5'; }
+    b.onclick = function () { if (!b.disabled) onClick(b); };
+    body.appendChild(b);
+    return b;
+  }
+  /* 本页的全部状态都从 GET /desk/feishu 来，每次动作完重画一次。 */
+  function paintFeishu(notice, isError) {
+    var body = document.getElementById('feishuBody');
+    if (!body) return;
+    body.innerHTML = '';
+    if (notice) feishuSub(body, notice, { error: isError });
+    if (!BASE && !TOKEN) {
+      body.appendChild(hEl('div', 'history__hint', '还没有连接桌面端'));
+      return;
+    }
+    body.appendChild(hEl('div', 'history__hint', '正在读取飞书配置…'));
+    feishuApi('GET').then(function (st) {
+      FEISHU_CACHE = st;
+      paintFeishuSummary(st);
+      body.innerHTML = '';
+      if (st.error) feishuSub(body, st.error, { error: true });
+
+      /* 2026-10-26 用户定调：「改为直接绑定会话 id 即可」。
+         所以这一页只留一条路：填一个 oc_ 开头的会话 ID，推给那个群 / 那个单聊。
+         绑定码还在（服务端要它防「随便谁都能绑」），但**用户不用管** ——
+         点确定时先自动取一个码，再把码和会话 ID 一起提交。 */
+      body.appendChild(hEl('div', 'history__group', '推送会话'));
+      var bd = hEl('div', 'setcard');
+      var brow = hEl('div', 'setrow');
+      brow.appendChild(elSpan('setrow__l', '会话 ID'));
+      /* bound_to 是服务端**打过码**的会话 id（只留末 6 位）。 */
+      brow.appendChild(elSpan('setrow__v', st.bound
+        ? ('已绑定 · ' + (st.bound_to || ('••' + (st.open_id_tail || ''))))
+        : '未绑定'));
+      bd.appendChild(brow);
+      if (st.bound && st.enabled != null) {
+        var trow = hEl('div', 'setrow');
+        trow.appendChild(elSpan('setrow__l', '推送开关'));
+        var tg = hEl('button', 'tgl' + (st.enabled ? ' is-on' : ''), '');
+        tg.type = 'button'; tg.setAttribute('aria-label', '飞书推送开关');
+        tg.onclick = function () {
+          feishuApi('POST', 'enable', { enabled: !st.enabled })
+            .then(function () { paintFeishu(st.enabled ? '已关闭飞书推送' : '已开启飞书推送'); })
+            .catch(function (e) { paintFeishu(e.message, true); });
+        };
+        trow.appendChild(tg);
+        bd.appendChild(trow);
+      }
+      body.appendChild(bd);
+
+      if (!st.bound) {
+        feishuSub(body, '填飞书里的会话 ID（oc_ 开头）就绑好了 —— 任务跑完 / 等你确认时会推到这个会话。取法：在飞书里打开那个群或和机器人的单聊，复制链接，末尾那串 oc_… 就是。');
+      } else {
+        feishuSub(body, '任务跑完 / 等你确认时会推一条卡片到这个会话。');
+      }
+
+      feishuBtn(body, st.bound ? '更换会话 ID' : '填会话 ID', function () {
+        openTextInputSheet({
+          title: '绑定推送会话',
+          value: '',
+          placeholder: 'oc_a90ab20986ffccf22b95939a1a8ce2a4',
+          emptyHint: '把 oc_ 开头的那串粘进来'
+        }, function (to) {
+          /* 绑定码对用户不可见：先取一个，再和会话 ID 一起提交。
+             失败时把服务端原话显示出来（认不出 oc_ / 凭据没配 / 发不出去，都会说清楚）。 */
+          feishuApi('POST', 'code').then(function (r) {
+            return feishuApi('POST', 'bind', { code: r.code, to: to });
+          }).then(function (r) {
+            FEISHU_CODE = '';
+            if (r.notice) paintFeishu('已绑定。' + r.notice, true);
+            else if (r.push && r.push.ok) paintFeishu('已绑定，测试卡片已经发到那个会话');
+            else paintFeishu('已绑定，但测试卡片没发出去：' + ((r.push && r.push.reason) || '未知原因'), true);
+          }).catch(function (e) { paintFeishu(e.message, true); });
+        });
+      }, { filled: !st.bound });
+
+      /* 应用凭据：推给会话（oc_）用的是应用机器人身份，所以这一栏是**必需**的。 */
+      body.appendChild(hEl('div', 'history__group', '飞书应用'));
+      var cred = hEl('div', 'setcard');
+      var row = hEl('div', 'setrow');
+      row.appendChild(elSpan('setrow__l', '应用凭据'));
+      row.appendChild(elSpan('setrow__v', st.configured ? ('已配置 · ' + (st.source || '')) : '未配置'));
+      cred.appendChild(row);
+      body.appendChild(cred);
+      if (!st.configured) {
+        feishuSub(body, '推给会话需要应用身份：填一次自建应用的 App ID / App Secret（只在桌面端保存，不会随页面下发）。');
+        feishuBtn(body, '填写应用凭据', function () {
+          openTextInputSheet({
+            title: '飞书应用凭据',
+            value: st.app_id || '',
+            placeholder: 'App ID（cli_ 开头）',
+            emptyHint: '请填 App ID',
+            secondary: { label: 'App Secret', placeholder: 'app_secret' }
+          }, function (id, sec) {
+            feishuApi('POST', 'config', { app_id: id, app_secret: sec })
+              .then(function () { paintFeishu('应用凭据已保存'); })
+              .catch(function (e) { paintFeishu(e.message, true); });
+          });
+        });
+      }
+
+      if (st.bound) {
+        feishuBtn(body, '发一条测试消息', function (b) {
+          b.disabled = true;
+          feishuApi('POST', 'test', { url: connUrlNow() }).then(function () {
+            paintFeishu('测试卡片已发出，去飞书看看');
+          }).catch(function (e) { paintFeishu('发送失败：' + e.message, true); });
+        }, { disabled: !st.configured });
+        feishuBtn(body, '解绑', function () {
+          feishuApi('POST', 'unbind').then(function () { paintFeishu('已解绑，不会再推送到飞书'); })
+            .catch(function (e) { paintFeishu(e.message, true); });
+        }, { danger: true });
+      }
+
+      /* ③ 最近的推送结果：用户报「没收到」时，这里能当场看到是哪一步失败。 */
+      var recent = Array.isArray(st.recent) ? st.recent.slice(-5).reverse() : [];
+      if (recent.length) {
+        body.appendChild(hEl('div', 'history__group', '最近的推送'));
+        var rc = hEl('div', 'setcard');
+        recent.forEach(function (r) {
+          var rr = hEl('div', 'setrow');
+          var col = hEl('span', 'setrow__l', (r.title || r.event || ''));
+          col.style.display = 'flex'; col.style.flexDirection = 'column'; col.style.gap = '2px';
+          /* 失败原因**一行写全**（不截断）：用户来这一页就是为了看「为什么没收到」，
+             截掉后半截等于没说。 */
+          if (!r.ok && r.error) col.appendChild(hEl('span', '', '失败：' + r.error));
+          rr.appendChild(col);
+          var when = '';
+          try { when = new Date(r.at).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }); } catch (e) {}
+          rr.appendChild(elSpan('setrow__v', (r.ok ? '已发送 · ' : '') + when));
+          rc.appendChild(rr);
+        });
+        body.appendChild(rc);
+      }
+    }).catch(function (e) {
+      body.innerHTML = '';
+      feishuSub(body, e.message || String(e), { error: true });
+    });
+  }
+  var FEISHU_CODE = '';
+
   function openNotifySettings() {
     openHostSheet('消息通知', function (body) {
       var st = notifyPermState();
@@ -7202,12 +8942,36 @@ html[data-theme="dark"] .tabfab__b{
         tip.style.display = 'block'; tip.style.margin = '2px 0 6px';
         body.appendChild(tip);
       }
-      /* ② 通知内容开关：用户来这个页面的主要目的，放前面。
+      /* ② 推送去向（2026-10-26）：系统通知只在本页开着时才会响，后台 / 锁屏收不到；
+         飞书推送由桌面端发，人不在 App 里也收得到。两个通道并列给出来，各自的开关在
+         自己的页面里（飞书 → 我的 → 飞书推送）。 */
+      var fe = FEISHU_CACHE;
+      var feTip = elSpan('pick__d', fe
+        ? ((fe.bound ? (fe.enabled ? '已开启' : '已绑定 · 已关闭') : '未绑定')
+          + (fe.configured ? '' : ' · 缺应用凭据')
+          + '　（人不在 App 里也能收到任务通知）')
+        : '由桌面端推送到你的飞书（人不在 App 里也能收到）');
+      feTip.style.display = 'block'; feTip.style.margin = '0 0 6px';
+      body.appendChild(feTip);
+      hRow(body, '飞书推送', '去管理 ›', function () { closeHostSheet(); showFeishuPage(); });
+      /* ③ 通知内容开关：用户来这个页面的主要目的，放前面。
          ⚠️ 「定时任务通知」开关撤掉（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(); });
+      /* ④ 页面来源自证（2026-10-26 加）。
+         「桌面改了页面、手机还是老样子」排查过两次：手机可能加载的是 **APK 内置的
+         ui.html**（file://，打包时的旧副本），而不是桌面的 /m/。这种情况在桌面上
+         怎么改都不会生效 —— 必须重打 APK。以前没有任何地方能看出这一点，
+         只能靠猜。这里把来源直接写在通知设置页底部，一眼可辨：
+           file: → App 内置页（旧）；http(s): → 桌面远程页（改了立刻生效）。 */
+      var srcLine = elSpan('pick__d', String(location.protocol) === 'file:'
+        ? '界面来源：App 内置页（随安装包固化，改页面需重打 APK）'
+        : '界面来源：桌面远程页 ' + String(location.host || '') + '（改页面即时生效）');
+      srcLine.style.display = 'block';
+      srcLine.style.margin = '10px 0 2px';
+      body.appendChild(srcLine);
       /* 「发一条测试通知」「通道诊断」两个入口 2026-10-25 用户定调撤掉（通道已通，
          正式 UI 不需要调试工具）。底层 notifyTest()/notifyDiagnose() 保留 ——
          通道再出问题时把它们挂回任意入口就能当场自证。 */
@@ -7215,25 +8979,135 @@ html[data-theme="dark"] .tabfab__b{
   }
 
   /* ── 轮询会话状态跳变 → 发通知（不重绘列表，避免打扰浏览）── */
-  var PREV_STATE = {}, POLL = null, FIRST_POLL = true;
-  function startPoll() { PREV_STATE = {}; FIRST_POLL = true; if (!POLL) POLL = setInterval(pollOnce, 5000); }
-  function stopPoll() { if (POLL) { clearInterval(POLL); POLL = null; } }
-  function pollOnce() {
+  var PREV_STATE = {}, FIRST_POLL = true;   // 定时器统一由 POLLER 管（2026-10-26 合并轮询）
+  /* 通知轮询**必须**在「连上桌面」这件事上启动，而不是「手动点连接」时才启动。
+     漏了这一点 = 通知功能看起来配好了、真机上永远不响（用户 2026-10-26 报障：
+     「会话结果通知没对接吗 没收到系统通知」）。
+     ⚠️ 为什么以前会漏：startPoll() 原先只在 connect() 里调，而 connect() 只在
+        「用户手填地址/扫码/点最近连接」时走；App 首屏启动走的是另一条路 ——
+        直接给 BASE/TOKEN 赋值（注入的 / 恢复的上次环境 / 最近用过的），
+        那三处**从不调 startPoll**。于是最常见的路径（App 启动即连上）轮询根本没跑，
+        notify('result') 一次都不会触发。
+     所以这里改成一个幂等的「连接已就绪」入口：谁把 BASE/TOKEN 落定，谁就调它。 */
+  /* ⚠️ startPoll **不清基线**（幂等，只负责把消费者登记上）：清基线交给 notifyFromList 里的
+     端点比对，否则「resume 列表 → 打开会话 → 再 resume」几次调用就会把快照清三四遍，
+     弹出一串假「任务完成」。
+     ⚠️ 2026-10-26 合并轮询：它**不再自挂定时器**，改为把通知登记成 tickPoller 的一个消费者。
+     通知的 wants() 恒为真 —— 列表页不可见时也要判跳变，这是后台通知的唯一来源。 */
+  function startPoll() {
+    pollConsumers.notify = {
+      wants: function () { return true; },
+      jobs: function () { return false; },   // 通知不看作业队列
+      run: function (list) { notifyFromList(list); },
+    };
+    startPoller();
+  }
+  function stopPoll() {
+    delete pollConsumers.notify;
+    if (POLLER) { clearInterval(POLLER); POLLER = null; }
+    POLL_EP = null; resetPollBaseline();
+  }
+  /* 连接落定后统一入口：启动通知轮询。
+     幂等（重复登记同一个消费者，后写覆盖前写；tickPoller 也只有一个），所以多处调用安全。
+     切环境时先 stopPoll 再由整页重载后的新页面重新起 —— 见 connect() 的 switchEnv 分支。 */
+  function ensureNotifyPoll() {
     if (!BASE && !TOKEN) return;
-    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
-    fetch(BASE + '/desk/sessions', { headers: hdr }).then(function (r) { return r.ok ? r.json() : []; })
-      .then(function (list) {
-        (Array.isArray(list) ? list : []).forEach(function (s) {
-          /* 通知按**会话级** status 判（同一条会话各轮一个记录，只看 state 会拿旧轮误报）。 */
-          var id = sidOf(s), st = String((s.status || s.state) || ''), prev = PREV_STATE[id];
-          if (!FIRST_POLL && prev !== undefined && prev !== st) {
-            if (st === 'done') notify('result', '任务完成', titleOf(s));
-            else if (st === 'waiting_approval') notify('confirm', '任务待确认', titleOf(s));
+    startPoll();
+  }
+  /* 会话状态缓存**跨轮询保留、只存**；页面生命周期 / 连接落定 / 最近用过的环境变了才重置。
+     以前这两件事一起挂在 startPoll 上（每次 ensureNotifyPoll → PREV_STATE={} + FIRST_POLL=true），
+     而 ensureNotifyPoll 会在连接落定 / 恢复上次环境 / 列表页重新出现时被调用 —— 于是快照在
+     「清空 → 记下 running → 又清空」之间来回抖：轮询恢复后 FIRST_POLL 那一轮把所有会话重新
+     当成「首次见到」，下一轮 round 状态一变就弹「任务完成」，一屏会话能连弹好几条。
+     现在只有端点真的变了、或轮询被停过（disconnect）才清基线。 */
+  var POLL_EP = null;
+  function pollEndpoint() { return String(BASE || '') + '|' + String(TOKEN || ''); }
+  function resetPollBaseline() { PREV_STATE = {}; FIRST_POLL = true; }
+  /* notifyFromList 只吃**已经拿到的**清单，判状态跳变并弹通知 / 推飞书。
+     拆出来的原因（2026-10-26 合并轮询）：列表轮询与通知轮询原先各自拉一次 /desk/sessions，
+     现在同一次 tick 的清单要**同时**喂给这两个消费者 —— 取数只有一份（pollSessionsShared），
+     判跳变留在这里，两边都不必再为了拿数据而多发一个请求。
+     list 为 null（拉失败 / 旧服务端回非数组）时什么都不做，也不清基线。 */
+  function notifyFromList(list) {
+    if (!Array.isArray(list)) return;
+    var ep = pollEndpoint();
+    if (ep !== POLL_EP) { POLL_EP = ep; resetPollBaseline(); }
+    /* 这一份就是**最新**登记表：顺手把宿主下发后卡在「等待中」的条目对一次账
+       （见 reconcileQueued）—— 不为此多打一发请求。 */
+    try { reconcileQueued(list); } catch (e) {}
+    list.forEach(function (s) {
+      /* 通知按**会话级** status 判（同一条会话各轮一个记录，只看 state 会拿旧轮误报）。 */
+      var id = sidOf(s), st = String((s.status || s.state) || ''), prev = PREV_STATE[id];
+      if (!FIRST_POLL && prev !== undefined && prev !== st) {
+        /* 通知只认「我们在跟踪时变完成的」：一条会话在本页里既没见过的 done(prev 为 undefined)
+           是历史遗留，不弹；running → done 才弹。 */
+        if (st === 'done' && prev === 'running') notify('result', '任务完成', titleOf(s));
+        else if (st === 'waiting_approval') notify('confirm', '任务待确认', titleOf(s));
+            /* 同一次跳变**顺带**推一条到飞书（2026-10-26）：系统通知只在 App 开着时响，
+               飞书那条覆盖「人在别的页面 / 锁屏」。按 ask_id 交给桌面端去重 ——
+               多台手机、多个 tab 各自轮询时，同一轮只会推一次（见 feishu.go push）。 */
+            if ((st === 'done' && prev === 'running') || st === 'waiting_approval') {
+              var kind = st === 'waiting_approval' ? 'confirm' : 'result';
+              if (NOTIFY[kind] !== false) pushFeishu(kind, s);
+            }
           }
           PREV_STATE[id] = st;
         });
         FIRST_POLL = false;
-      }).catch(function () {});
+  }
+  /* pollOnce 一次 tick：拉清单 → 交给 notifyFromList 判跳变。
+     ⚠️ 它**只服务通知**（列表页不可见时也要跑，通知是后台能力）。列表页可见时，
+     清单由 startListPoll 那一拍统一取（见 pollSessionsShared）—— 两条 tick 会在
+     同一秒各拉一次，所以下面 tickOnce 加了一把「同一拍复用」的短门：
+     500ms 内已经拉过的清单直接复用，不再发请求。 */
+  var LAST_FETCH = { at: 0, list: null };
+  function pollOnce() {
+    if (!BASE && !TOKEN) return;
+    /* 同一拍复用：列表轮询刚拉过（<500ms）就用它那份，别为通知再发一个请求。
+       这个窗口比两次 tick 的间隔（5s）小两个数量级，不会掩盖真实的状态变化。 */
+    if (LAST_FETCH.list && Date.now() - LAST_FETCH.at < 500) {
+      notifyFromList(LAST_FETCH.list);
+      return;
+    }
+    var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
+    fetch(BASE + '/desk/sessions', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : []; })
+      .then(function (list) {
+        if (Array.isArray(list)) { LAST_FETCH = { at: Date.now(), list: list }; }
+        notifyFromList(list);
+      })
+      .catch(function () { notifyWarningOnce(); });
+  }
+  /* 过了这个点（首次在飞书里绑上 / 上次成功之后）的跳变才推：避免刚打开 App 就把
+     几小时前就跑完的会话一股脑推到飞书（那时用户已经不在手机上看了）。
+     ⚠️ 这是**客户端侧的礼貌过滤**，不是正确性保证；正确性靠桌面端的幂等键。 */
+  var FEISHU_NOTIFY_AFTER = 0;
+  function pushFeishu(event, s) {
+    if (!BASE && !TOKEN) return;
+    /* 飞书开关没开时桌面端会回 {disabled:true}，200 + 无副作用；这里不必先查状态，
+       省一次往返（状态可能是几分钟前的缓存）。 */
+    var askId = s.status_ask_id || s.ask_id || s.request_id || '';
+    if (!askId) return;   // 没有这一轮的身份就没法去重 —— 宁可不推，也不刷屏
+    var at = s.updated_at ? Date.parse(s.updated_at) : NaN;
+    if (isFinite(at) && FEISHU_NOTIFY_AFTER && at < FEISHU_NOTIFY_AFTER) return;
+    var title = titleOf(s);
+    feishuApi('POST', 'push', {
+      event: event, ask_id: askId, session_id: sidOf(s) || '',
+      title: title === sidOf(s) ? '' : title,
+      /* 手机最清楚自己现在是怎么连上的（局域网 / 隧道 / 域名）：卡片里的
+         「打开」按钮就用它拼，服务端有公网地址时优先用自己的。 */
+      url: connUrlNow()
+    }).catch(function (e) {
+      /* 推送失败不打扰用户（系统通知已经弹了）；只记一笔，排查时看控制台。 */
+      if (window.console && console.warn) console.warn('[feishu] 推送失败：', e && e.message ? e.message : e);
+    });
+  }
+  /* 轮询失败警告只弹一次（传输层断了以前直接吞掉，用户只看到「一直没通知」）。 */
+  var POLL_WARNED = false;
+  function notifyWarningOnce() {
+    if (POLL_WARNED) return;
+    POLL_WARNED = true;
+    if (window.console && console.warn) console.warn('[notify] /desk/sessions 拉取失败，状态通知将暂停');
   }
 
   /* 思考模式选择器：写**当前这条会话**的档位（默认最高）。 */
@@ -7272,32 +9146,37 @@ html[data-theme="dark"] .tabfab__b{
       hRow(body, '默认（不属于任何空间）', null, function () { WS = ''; saveWs(); applyWs(); closeHostSheet(); paintRunSettings(); }, false, !WS);
       keys.forEach(function (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, spaceLabel(w), it && it.alias ? '自定义' : null, function () { WS = w; saveWs(); applyWs(); closeHostSheet(); paintRunSettings(); }, false, !!WS && spaceKey(WS) === spaceKey(w),
+          /* ⚠️ 每行都带「✎」「✕」（2026-10-26，用户：「空间都可以修改和删除」）：
+             以前只有「自定义空间」那一类有按钮，根目录下真有的 magic-* 目录、
+             会话跑出来的空间既改不了名也删不掉 —— 用户看到列表里有一项却动不了它。
+             现在三类来源统一登记到「空间登记册」（见 normSpaces），动作对所有行一致。
+             行本身仍是「选中这个空间」（动作是行内的 span，不是按钮 —— 行是 <button>，
+             里面再塞按钮 HTML 不允许）。 */
+          [
+            { label: '✎', title: '重命名', onClick: function () { openSpaceAliasSheet(w); } },
+            { label: '✕', title: '删除空间', onClick: function () { openSpaceDeleteSheet(w); } }
+          ]);
       });
       hRow(body, '自定义路径…', '＋', openCustomPathSheet);
     });
   }
-  /* 自定义空间的别名：给目录起一个**显示名**，之后各处显示它而不是路径。
-     留空 = 回到「最后一级文件夹名」（见 spaceLabel）。 */
-  function openSpaceAliasSheet(item) {
+  /* 空间改名：给目录起一个**显示名**，之后各处显示它而不是路径。
+     留空 = 回到「最后一级文件夹名」（见 spaceLabel）。
+     ⚠️ 传进来的是**路径**而不是登记项：根目录目录与会话空间原先不在册子里，
+        改名时现登记一条（ensureSpaceEntry）—— 同一个目录只登记一次。 */
+  function openSpaceAliasSheet(path) {
+    var it = ensureSpaceEntry(path);
     openTextInputSheet({
       title: '空间别名',
-      value: item.alias || '',
+      value: it.alias || '',
       placeholder: '留空 = 用文件夹名',
       allowEmpty: true
     }, function (alias) {
-      item.alias = String(alias || '').trim();
+      it.alias = String(alias || '').trim();
       saveSpaces();
       /* 别名一改，所有显示它的地方都要跟着变：运行设置页 / 空间选择器 / 任务页分组头。 */
       paintRunSettings();
@@ -7305,12 +9184,17 @@ html[data-theme="dark"] .tabfab__b{
       openWorkspacePicker();   // 回到选择器，让用户当场看见新名字
     });
   }
-  /* 删除自定义空间：二次确认后从清单摘掉（**只删登记，不删目录** —— 磁盘上的文件
+  /* 删除空间：二次确认后把它从空间列表里移除（**只删登记，不删目录** —— 磁盘上的文件
      原样不动，用户的代码/文档不能因为一个 UI 操作消失）。当前生效的 WS 正是它时
-     回落「默认」，并当场把对话组件的 workspace 也清掉（否则下一轮还会带着已删空间发）。 */
-  function openSpaceDeleteSheet(item) {
+     回落「默认」，并当场把对话组件的 workspace 也清掉（否则下一轮还会带着已删空间发）。
+     ⚠️ 移除的实现是**打 hidden 标记**而不是从册子里删条目：
+        册子里的 alias 得留着（用户下次把这个目录加回来，别名还在），
+        而且根目录目录 / 会话空间本来就没有「条目」可删 —— 它们是磁盘与会话里客观存在的，
+        只能「不再作为空间出现」。 */
+  function openSpaceDeleteSheet(path) {
+    var label = spaceLabel(path);
     openHostSheet('删除空间', function (body) {
-      var tip = hEl('div', 'pick__d', '从空间列表移除「' + spaceLabel(item.path) + '」？目录里的文件不会被删除。');
+      var tip = hEl('div', 'pick__d', '从空间列表移除「' + label + '」？目录里的文件不会被删除。');
       tip.style.textAlign = 'left';
       tip.style.lineHeight = '1.6';
       body.appendChild(tip);
@@ -7322,10 +9206,10 @@ html[data-theme="dark"] .tabfab__b{
       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; });
+        var it = ensureSpaceEntry(path);
+        it.hidden = true;
         saveSpaces();
-        if (spaceKey(WS) === k) { WS = ''; saveWs(); applyWs(); }
+        if (spaceKey(WS) === spaceKey(path)) { WS = ''; saveWs(); applyWs(); }
         closeHostSheet();
         paintRunSettings();
         renderSessions(LAST_SESSIONS);
@@ -7391,10 +9275,13 @@ html[data-theme="dark"] .tabfab__b{
   }
   function paintSuggestPref() {
     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));
+    var main = SUGGEST.engine ? SUGGEST.engine : '不开启';
+    paintEnginePair(document.getElementById('suggestEngine'), main,
+      fallbackLine(SUGGEST.fbEngine, SUGGEST.fbModel),
+      SUGGEST.engine ? modelInlineText(SUGGEST.model, SUGGEST.engine) : '');
+    var mEl = document.getElementById('suggestModel');
+    /* 没开启建议引擎时这一格留空：写「—」只是多一个占位符号（2026-10-26 简约口径）。 */
+    if (mEl) mEl.textContent = SUGGEST.engine ? (SUGGEST.model ? qaModelText(SUGGEST.model, SUGGEST.engine) : '跟随引擎') : '';
   }
   function applySuggestToLive() {
     if (conv && typeof conv.setSuggestEngine === 'function') {
@@ -7429,10 +9316,17 @@ html[data-theme="dark"] .tabfab__b{
   function paintRunPref() {
     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));
+    /* 引擎格只放引擎名（主一行、备一行）；具体模型在下一行「默认模型」里。 */
+    var main = RUN_PREF.engine ? RUN_PREF.engine : '自动（首个可用）';
+    /* 模型与引擎**同一行**：主行画成「引擎 · 模型」；没选模型只画引擎名。 */
+    paintEnginePair(document.getElementById('defaultEngine'), main,
+      fallbackLine(RUN_PREF.fbEngine, RUN_PREF.fbModel), modelInlineText(RUN_PREF.model, RUN_PREF.engine));
+    var mEl = document.getElementById('defaultModel');
+    if (mEl) mEl.textContent = RUN_PREF.model ? qaModelText(RUN_PREF.model, RUN_PREF.engine) : '跟随引擎';
+  }
+  /* 同一格里「引擎 · 模型」里的模型那半截；没选模型 → 空串（不写「跟随引擎」占位）。 */
+  function modelInlineText(model, engine) {
+    return model ? qaModelText(model, engine) : '';
   }
   /* 备用那一行（第二行，小一档）：没配就空串 = 不画。
      ⚠️ 不要和主引擎挤在同一行 —— `setrow__v` 是单行省略，长组合会被截成
@@ -7441,10 +9335,18 @@ html[data-theme="dark"] .tabfab__b{
     if (!engine) return '';
     return '备 ' + engine + (model ? ' · ' + qaModelText(model, engine) : '');
   }
-  function paintEnginePair(el, mainText, fbText) {
+  /* modelText 非空时主行画成「引擎 · 模型」（同一行）。只有「我的」那两行传它；
+     团队配置里仍只画引擎名（那边模型写在下面一行的规则里），所以做成可选参数。 */
+  function paintEnginePair(el, mainText, fbText, modelText) {
     if (!el) return;
     el.innerHTML = '';
-    el.appendChild(hEl('span', 'setrow__pair-main', mainText));
+    var mainEl = hEl('span', 'setrow__pair-main');
+    mainEl.appendChild(document.createTextNode(mainText));
+    if (modelText) {
+      mainEl.appendChild(hEl('span', 'engmodel__mid', '·'));
+      mainEl.appendChild(hEl('span', 'engmodel__model', modelText));
+    }
+    el.appendChild(mainEl);
     if (fbText) el.appendChild(hEl('span', 'setrow__pair-fb', fbText));
   }
 
@@ -7879,12 +9781,33 @@ html[data-theme="dark"] .tabfab__b{
   }
   /* 进选择器的引擎：探测成功、**已登录**且**能列出模型**。没登录 / 取不到清单的
      （如 trae、登出后的 codebuddy-ai）不出现 —— 「登录了几个账号就显示几个」
-     （2026-10-25 用户要求）。 */
+     （2026-10-25 用户要求）。
+     ⚠️「取不到清单」分两种（core --engines 的 models_source）：
+       none   = 引擎本身不提供模型选择（arkclaw 按 claw_id 绑模型、codebuddy-gateway
+                用网关进程的模型）→ 不是故障，保留（右列显示「引擎默认」）；
+       failed = 有来源但探测失败（CLI 非 0 退出）→ 隐藏。
+     老 core 没该字段时按 ErrNoModelSource 的固定文案前缀兜底。 */
+  function modelsSourceOf(en) {
+    return en.models_source || en.modelsSource || '';
+  }
+  /* 「没有模型可选」的原因，翻成人话（core 的 models_note 是英文诊断串）。
+     arkclaw / MagicAI 的模型绑在网关的 claw_id 上，codebuddy-gateway 的绑在网关进程上 ——
+     都不是"选不了模型就不可用"。 */
+  function noModelChoiceHint(en) {
+    var note = String(en.models_note || en.modelsNote || '');
+    if (/claw_id/i.test(note)) return '模型由网关的 claw_id 决定';
+    if (/gateway/i.test(note)) return '模型由网关进程决定';
+    return '不指定模型，由引擎自己挑';
+  }
   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;
+      var src = modelsSourceOf(en);
+      if (src === 'none') return true;
+      if (src === 'failed') return false;
+      if (/^no dynamic model source/.test(en.models_note || en.modelsNote || '')) return true;
+      return (en.models || []).length > 0 || !(en.models_note || en.modelsNote);
     });
   }
   /* 引擎行副标题：有模型报数量，否则「引擎默认」；多账号引擎前面带上登录的账号昵称
@@ -7964,7 +9887,13 @@ html[data-theme="dark"] .tabfab__b{
         var stale = enginesStaleHint();
         if (stale) body.appendChild(stale);
         var avail = pickableEngines(list);
-        if (cfg.sort) avail.sort(cfg.sort);
+        /* 先按引擎名排；cfg.sort 只做「置顶」（返回 -1/1 才生效，0 保持字母序）。
+           2026-10-26 用户：引擎显示乱序，要按字母顺序 —— 探测结果按安装顺序返回，不排就是乱的。 */
+        avail.sort(function (a, b) {
+          var r = cfg.sort ? cfg.sort(a, b) : 0;
+          if (r) return r;
+          return String(a.engine).localeCompare(String(b.engine), undefined, { sensitivity: 'base' });
+        });
         if (!avail.length) {
           var d = hEl('div', 'history__hint',
             '没有可用引擎：先在这台机器上装一个（终端跑 magic-agent --engines 会给出安装命令）。');
@@ -8094,7 +10023,6 @@ html[data-theme="dark"] .tabfab__b{
     var offLabel = o.offLabel || '自动';
     var offDesc = o.offDesc || '首个可用引擎';
     var modelDefaultDesc = o.modelDefaultDesc || '不指定模型，由引擎自己挑';
-
     var wrap = hEl('div', 'pick__cols');
     var left = hEl('div', 'pick__col');
     var right = hEl('div', 'pick__col pick__col--r');
@@ -8149,7 +10077,8 @@ html[data-theme="dark"] .tabfab__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.appendChild(hEl('span', 'pick__cd',
+          modelsSourceOf(cur) === 'none' ? noModelChoiceHint(cur) : modelDefaultDesc));
         d.onclick = function () { pick(cur.engine, ''); };
         right.appendChild(d);
       }
@@ -8232,68 +10161,383 @@ html[data-theme="dark"] .tabfab__b{
      链路（见 internal/client/restart.go）：POST /desk/restart → 桌面端**先立标志、
      先答 200**（重复点击答 already_pending，不会再起第二个助手），1 秒后由**进程内
      定时器**拉起一个脱离终端的 `magic-client restart` 助手停旧实例、按状态文件里的
-     参数拉起新实例（端口 / 令牌沿用，手机里存的地址不用改）。
+     参数拉起新实例。
 
-     ⚠️ 会话是桌面端起的子进程：重启会把**正在跑的所有会话**一起中断 → 点之前必须确认。
+     ⚠️ 会话是**这个实例**起的子进程：重启会中断它们（状态变「中断」，重开会话可继续）。
+        **不影响**同机别的客户端实例 —— 每台实例只停自己起的会话，判据是那条会话自己的
+        pid 还在不在（见 internal/session/session.go 的 gone 判定），不是「客户端重启了没」。
+        所以这里只说「当前连接的这套服务」，不要把「桌面端所有会话」都说进去（2026-10-26
+        用户指出：桌面端还开着另一个客户端时，这句提示与事实不符）。
      ⚠️ 判断「好了没」：旧实例认账时 /desk/health 会带 restarting=true（它马上要下线，
-        可当成「看到下线」），再探到**不带** restarting 的 200 才算新实例起来了。 */
+        可当成「看到下线」），再探到**不带** restarting 的 200 才算新实例起来了。
+     ⚠️ 地址 / 令牌可能变（换网、换端口、令牌重发）：见 followRestartMoved。
+     ⚠️⚠️ 只见「200 回来了」还不够（2026-10-27 用户：「点了手机端重启 好像没效果」）：
+        重启换的是**进程**，会话 / 任务 / 设置全在盘上，界面重启前后长得一模一样 ——
+        探活一回来就弹「桌面端已重启」，用户看到列表没变，只会判「没效果」。
+        所以必须拿**换代的硬证据**：health 里的 `pid` / `startedAt`（2026-10-27 起服务端才给）。
+        没给（老插件）就如实说「已完成重启请求」，不要暗示用户去看什么变化。 */
   function restartClient() {
     if (!TOKEN && !BASE) { toast('还没连接桌面'); return; }
-    if (!window.confirm('重启桌面端服务？\n\n正在运行的会话会被中断（状态会变成「中断」，重新打开会话可继续）。')) return;
+    if (!window.confirm('重启这套桌面端服务？\n\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 } : {};
+    /* 重启前的身份指纹：用来证明「换了一代」。拿不到不影响重启，只是没法给出硬证据。
+       ⚠️ 必须在 POST **之前**读 —— 重启很快（3~7 秒），POST 之后旧实例可能已经没了。 */
+    var before = { pid: null, startedAt: null };
+    var beforeReady = Promise.resolve();
+    try {
+      beforeReady = fetch(apiOrigin() + '/desk/health', {
+        headers: apiToken() ? { 'X-Magic-Token': apiToken() } : {}, cache: 'no-store'
+      })
+        .then(function (r) { return r.ok ? r.json() : null; })
+        .then(function (d) {
+          if (!d) return;
+          if (typeof d.pid === 'number') before.pid = d.pid;
+          if (d.startedAt) before.startedAt = d.startedAt;
+        })
+        .catch(function () { /* 读不到就当没有指纹，不影响重启本身 */ });
+    } catch (e) { /* 极老的 WebView 没有 Promise 兜底：直接跳过指纹 */ }
+    /* 重启会比对令牌 —— 必须带「这个地址此刻认的那把」：同源页的令牌可能只注入在
+       BASE 为空那一侧（见 apiToken），这里先让两条来源都试一下。 */
+    var hdr = apiToken() ? { 'X-Magic-Token': apiToken() } : {};
+    if (TOKEN && injectedToken && TOKEN !== injectedToken && BASE === '') hdr['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 })
+    beforeReady
+      .then(function () { return fetch(apiOrigin() + '/desk/restart', { method: 'POST', headers: hdr }); })
       .then(function (r) {
         if (r.ok) return null;
+        /* 404/405 = 桌面端版本过旧，没有这条路由；其余非 2xx = 服务端**明确拒绝**
+           （典型 409：这套实例没有状态记录，压根不支持自重启）。
+           两种情况都**没有**发出任何重启 —— 必须与「发出去了但连不上」分开说，
+           否则用户会对着「重启中…」白等，也不知道该去桌面敲哪条命令。 */
         return r.json().catch(function () { return {}; }).then(function (d) {
-          throw new Error((d && d.error) || ('HTTP ' + r.status));
+          var e = new Error((d && d.error) || ('HTTP ' + r.status));
+          e.refused = true;                 // 被拒绝：没发出、不必等探活
+          e.status = r.status;
+          throw e;
         });
       })
-      .then(function () { return waitRestartBack(); })
-      .then(function () {
-        done('重启', '桌面端已重启');
+      .then(function () { return waitRestartBack(before); })
+      .then(function (back) {
+        back = back || {};
+        /* 新地址 + 新令牌（见 followRestartMoved）：连上了再换入口，
+           换完整页重载 —— 会话轮询、通知、排队都绑定在 BASE/TOKEN 上，就地改会分叉。 */
+        if (back.follow) {
+          followRestartMoved(back.url, back.token || '', { btn: btn, val: val });
+          return;
+        }
+        /* 「已重启」这句话必须有证据才说（2026-10-27 用户「好像没效果」的根因）：
+           进程换了、会话与任务却一个不少（全在盘上），界面看起来毫无变化。
+           拿 pid / startedAt 对比，把变化摆出来；拿不到就说清楚「没有可核对的证据」。 */
+        if (back.changed) {
+          var what = back.pidChanged && back.pidBefore
+            ? '（pid ' + back.pidBefore + ' → ' + back.pidAfter + '）'
+            : '';
+          done('已重启', '桌面端已重启' + what + '；会话与任务都在盘上，不受影响');
+        } else if (back.pidAfter === null && back.pidBefore === null) {
+          /* 老插件没有 pid 字段：不编造「已换新」的证据。 */
+          done('重启', '重启请求已完成；这个桌面端版本不提供 pid，无法核对是否换代，可看桌面日志确认');
+        } else {
+          done('重启', '重启请求已完成，但没检测到换代：pid 仍是 ' + (back.pidAfter || '?') + '，可能重启没生效');
+        }
         loadSessions(true);   // 新实例的会话表（状态已按重启后的实况归一过）
       })
       .catch(function (e) {
-        done('重启', '重启未确认：' + (e && e.message ? e.message : e));
+        var msg = (e && e.message) ? e.message : String(e);
+        /* 服务端明确拒绝（409 等）：按钮如实回到「重启」，并把拒绝理由原样给出来。
+           那句话本身就是「该怎么自救」，不要再包装成「重启已发出」——
+           过去的文案把这类拒绝渲染成「已发出但连不上」，用户会一直等一个永不会来的重启。 */
+        if (e && e.refused) {
+          done('重启', msg);
+          console.warn('[restart] 服务端拒绝：', msg);
+          return;
+        }
+        /* 探活等不到新实例，但旧实例死前交代过「新实例在哪」：旧地址已经报废，
+           这不是失败，是地址变了（见 restartHandoff / followRestartMoved）。 */
+        if (e && e.handoff && e.handoff.urls && e.handoff.urls.length) {
+          followRestartMoved(e.handoff.urls[0], e.handoff.token || '', { btn: btn, val: val });
+          return;
+        }
+        /* 旧地址连不上、也没拿到交接：住址多半换了，但也可能只是重启失败。
+           别让用户对着「连不上」干等 —— 给一句能照着做的话（2026-10-25）。 */
+        if (e && e.moved) msg += '；旧地址可能已换（IP / 端口变了），请确认电脑当前的地址，或在环境里重新扫码';
+        else msg = '重启已发出，但暂时连不上桌面端：' + msg + '（可能是还没起来、或地址变了；稍后会自动重试）';
+        done('重启', msg);
+        console.warn('[restart]', msg, e && e.stack);   // 排障留痕（控制台）
+
       });
   }
   /* 等桌面端**真的换了一代**：旧实例认账（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;
+     输的那个要等 ready 超时），别让按钮永远停在「重启中…」。
+     探活时顺手把旧实例交代的「新实例地址 + 令牌」（health.restartHandoff）拿走：
+     旧实例马上要死，交接只在这个窗口里给。
+
+     before：调用前抓的身份指纹 {pid, startedAt}（可以为空 = 老插件没有这两个字段）。
+     返回 {url, token, follow, changed, pidBefore, pidAfter}：
+     `changed` = 拿 pid / startedAt 证实**换了一代**（2026-10-27 新增，治「好像没效果」）。 */
+  function waitRestartBack(before) {
+    var hdr = apiToken() ? { 'X-Magic-Token': apiToken() } : {};
+    var launchedAt = Date.now();
+    var deadline = launchedAt + 60000;
+    var sawDown = false, moved = false, settled = false;
+    var handoff = null, lostAt = 0, triedAt = 0;
+    before = before || {};
+    var pidBefore = (typeof before.pid === 'number') ? before.pid : null;
+    var startBefore = before.startedAt || null;
+    /* 换代判据：pid 变了，或启动时刻变了。两个都拿不到 = 无法判断（不编造结论）。 */
+    var isNewGen = function (d) {
+      if (!d) return false;
+      if (pidBefore !== null && typeof d.pid === 'number') return d.pid !== pidBefore;
+      if (startBefore && d.startedAt) return d.startedAt !== startBefore;
+      return false;
+    };
+    /* 交接里的候选入口一拿到就去试：新实例可能开在**另一个域名/端口**上，只等旧地址
+       恢复等于白等 60 秒（用户就看着「重启中…」发呆）。公网域名在 urls 第一位。 */
+    var probeHandoff = function (resolve) {
+      if (settled || !handoff) return;
+      var now = Date.now();
+      if (now - triedAt < 900) return;   // 别每 400ms 一轮就砸一遍：1 秒一试足够
+      triedAt = now;
+      var urls = (handoff.urls || []).slice(0, 3), tok = handoff.token || '';
+      var h2 = tok ? { 'X-Magic-Token': tok } : {};
+      /* 每个候选都要有超时：隧道半死时 fetch 可能挂很久，它会拖住整条探活链，
+         让界面一直停在「重启中…」（2026-10-25 真机复现）。 */
+      var once = function (u) {
+        return new Promise(function (res) {
+          var done = false;
+          var t = setTimeout(function () { if (!done) { done = true; res(null); } }, 2500);
+          fetch(u + '/desk/health', { headers: h2, cache: 'no-store' })
+            .then(function (r) { return r.ok ? r.json().catch(function () { return {}; }) : null; })
+            .then(function (d) { if (done) return; done = true; clearTimeout(t); res(d); })
+            .catch(function () { if (done) return; done = true; clearTimeout(t); res(null); });
+        });
+      };
+      var again = function (i) {
+        if (settled || i >= urls.length) return;
+        var u = String(urls[i] || '').replace(/\/+$/, '');
+        if (!u) return again(i + 1);
+        once(u).then(function (d) {
+          if (settled) return;
+          /* 200 就算数（老插件的 health 可能没有 ok 字段）。令牌不对会是 401 → null。 */
+          if (d) { settled = true; return resolve({ url: u, token: tok, follow: true, handoff: true }); }
+          again(i + 1);
+        });
+      };
+      again(0);
+    };
     return new Promise(function (resolve, reject) {
       (function tick() {
         if (settled) return;
-        fetch(BASE + '/desk/health', { headers: hdr, cache: 'no-store' })
+        fetch(apiOrigin() + '/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) {
+              /* 连不上：旧实例真的走了。但别把「重启前就连不上」也算成「看到下线」——
+                 那样第一次探活就判新一代，等于什么都没确认。 */
+              sawDown = true;
+              if (Date.now() - launchedAt > 2000) moved = true;
+              return;
+            }
+            /* 交接要**先**收下：旧实例在 restarting 期间就会带上新入口，别因为提前 return 漏掉。 */
+            if (d.restartHandoff && d.restartHandoff.urls && d.restartHandoff.urls.length) handoff = d.restartHandoff;
             if (d.restarting) { sawDown = true; return; }       // 旧实例认账（restarting 标志）：定时器到点就下线
-            if (sawDown) { settled = true; return resolve(d); } // 不带标志的 200 = 新一代
+            if (sawDown) {
+              /* 不含标志的 200 = 新实例（地址没变）。2026-10-27 起再核对 pid / startedAt，
+                 把「换代」从推测变成证据；老插件没有这两个字段 → changed 为 false，如实说。 */
+              settled = true;
+              var pa = (typeof d.pid === 'number') ? d.pid : null;
+              return resolve({
+                url: BASE, token: apiToken(), follow: false,
+                changed: isNewGen(d),
+                pidBefore: pidBefore, pidAfter: pa,
+                pidChanged: (pidBefore !== null && pa !== null && pa !== pidBefore)
+              });
+            }
+            /* 没看到下线、但这一代**已经换了**（重启太快，中间的空窗被我们错过了）：
+               同样算成功 —— 只要 pid 变了，就是新进程在应答。 */
+            if (isNewGen(d)) {
+              settled = true;
+              var pb = (typeof d.pid === 'number') ? d.pid : null;
+              return resolve({
+                url: BASE, token: apiToken(), follow: false,
+                changed: true, pidBefore: pidBefore, pidAfter: pb,
+                pidChanged: (pidBefore !== null && pb !== null && pb !== pidBefore)
+              });
+            }
+          })
+          .catch(function () {
+            if (!lostAt) lostAt = Date.now();
+            sawDown = true;
+            if (Date.now() - launchedAt > 2000) moved = true;
           })
-          .catch(function () { sawDown = true; })
           .then(function () {
             if (settled) return;                      // 已确认恢复：不再空转探活
-            if (Date.now() > deadline) { settled = true; return reject(new Error('等桌面端恢复超时')); }
+            probeHandoff(resolve);                    // 旧地址还没回来？试试它交代的新入口
+            if (Date.now() > deadline) {
+              settled = true;
+              /* 仍然连不上 + 旧实例死前交代过新入口 = 地址真的换了（旧地址 401 / 连不上都算）。 */
+              if (handoff) { var e1 = new Error('旧地址已不可用'); e1.handoff = handoff; return reject(e1); }
+              var e2 = new Error('等桌面端恢复超时');
+              e2.moved = moved;
+              return reject(e2);
+            }
             setTimeout(tick, 400);
           });
       })();
     });
   }
 
+  /* ── 重启 / 升级后地址或令牌变了：把「原环境」的连接地址与令牌换成新实例的 ──
+     2026-10-25 用户：「重启后如果地址变化了也要刷新原环境的连接地址和token」。
+
+     为什么旧地址会失效：手机存的是「地址 + 令牌」。换 Wi-Fi / 热点 → 网卡 IP 变了；
+     端口撞了 → 换端口；状态文件丢了 → 令牌重发。旧实例死前把「新实例的手机入口 +
+     令牌」挂在自己的 /desk/health.restartHandoff 上（见 restartHandoff），这里取走。
+
+     口径（三条都是硬约束）：
+       · 只改**这一条**环境：url / token / id 换成新的，eid 与名字不动 —— eid 是环境的
+         稳定身份（见 ensureEnvId），排队任务、配置槽、空间都还挂在这条名下；
+       · **一律以新连上的那台实例自己回报的入口为准**：交接给的地址也来自旧实例的网卡
+         枚举（退出 Wi-Fi 时它可能还是旧的），所以连上之后优先用 health.lanUrls /
+         publicUrl；永远不在没验证连通之前改地址，改错了就再也连不回来；
+       · 换完整页重载：会话轮询、通知、排队、会话组件都绑定在 BASE / TOKEN 上，
+         就地改会把内存里的旧连接状态带到新入口上（同 switchEnv 的道理）。 */
+  function normOrigin(u) {
+    try { return new URL(String(u || '')).origin; } catch (e) { return ''; }
+  }
+  function sameOriginUrl(a, list) {
+    var na = normOrigin(a);
+    if (!na) return false;
+    for (var i = 0; i < (list || []).length; i++) if (normOrigin(list[i]) === na) return true;
+    return false;
+  }
+  /* 「原环境」那一条记录：同一台桌面可能有多条入口（公司本地 / 公司远程，共享 eid）；
+     当前要是同源页那种临时记录（壳注入的地址 + 令牌），这条原环境才找得到 ——
+     认不出来就按旧地址 + 旧令牌找。 */
+  function keepSameConn(oldUrl) {
+    if (oldUrl) {
+      var cur = activeConn();
+      if (cur && cur.eid) {
+        var list = loadConns();
+        for (var i = 0; i < list.length; i++) if (list[i] && list[i].eid === cur.eid) return list[i];
+      }
+    }
+    return findConn(connIdOf({ url: oldUrl, token: apiToken() }));
+  }
+  /* 把一个原点换到另一个原点，保留路径与查询参数（http://a:9100 → http://b:9200）。 */
+  function swapOrigin(from, to) {
+    var a, b;
+    try { a = new URL(String(from || '')); b = new URL(String(to || '')); } catch (e) { return ''; }
+    /* 相对路径的 URL 没有 origin（base = 当前页）：这种入口换不了，交给同源分支。 */
+    if (!a.origin || a.origin === 'null' || !b.origin || b.origin === 'null') return '';
+    /* 纯 origin 的入口别留尾斜杠：存成 `https://x/` 的话，各处 `apiOrigin() + '/desk/…'`
+       会拼出 `https://x//desk/…` —— 隧道/WAF 上可能被规范化成 301，白多一跳。 */
+    if (a.pathname === '/' && !a.search && !a.hash) return b.origin;
+    return b.origin + a.pathname + a.search + a.hash;
+  }
+  function followRestartMoved(url, token, ui) {
+    var val = ui && ui.val;
+    var fail = function (msg) {
+      if (val) val.textContent = '重启';
+      if (ui && ui.btn) ui.btn.disabled = false;
+      toast('桌面端已重启，但没能自动更新连接：' + msg + '。请在环境里重新扫码（新地址：' + (url || '未知') + '）');
+    };
+    var probe = function (u, tok) {
+      var h = tok ? { 'X-Magic-Token': tok } : {};
+      return fetch(u + '/desk/health', { headers: h, cache: 'no-store' })
+        .then(function (r) { return r.ok ? r.json().catch(function () { return {}; }) : null; })
+        .catch(function () { return null; });
+    };
+    probe(url, token).then(function (d) {
+      if (!d) return { base: '', health: null };   // 交接给的地址也连不上：交给下面报失败
+      /* 新实例自己枚举的入口（它眼里此刻的网卡）+ 公网隧道：优先于交接值。 */
+      var live = [];
+      if (d.publicUrl) live.push(d.publicUrl);
+      if (d.lanUrls && d.lanUrls.length) live = live.concat(d.lanUrls);
+      live = live.filter(function (u) { return u && normOrigin(u) !== normOrigin(url); });
+      if (!live.length) return { base: url, health: d };
+      return Promise.all(live.map(function (u) {
+        return probe(u, token).then(function (dd) { return dd ? u : ''; });
+      })).then(function (hits) {
+        for (var i = 0; i < hits.length; i++) if (hits[i]) return { base: hits[i], health: d };
+        return { base: url, health: d };
+      });
+    }).then(function (r) {
+      if (!r.base) { fail('新地址也连不上'); return; }
+      var newOrigin = normOrigin(r.base);
+      var oldOrigin = normOrigin(apiOrigin());
+      if (!newOrigin) { fail('新地址无法解析'); return; }
+      /* 同源页（web 壳 / 远程界面，BASE 为空）：入口由页面本身决定，换不了 ——
+         如果新入口刚验证过可用、且页面就打开在它上面，说明本页已经在新地址上，什么也不用改。
+         ⚠️ 这里只比 r.base：旧入口（就是本页地址）一定和 location.origin 相同，
+            拿它比会把「地址真变了」误判成「没变」。 */
+      if (!BASE && newOrigin === normOrigin(location.origin)) {
+        if (val) val.textContent = '重启';
+        if (ui && ui.btn) ui.btn.disabled = false;
+        loadSessions(true);
+        return;
+      }
+      if (newOrigin === oldOrigin && String(token || '') === String(apiToken())) {
+        /* 地址与令牌都没变：不用改任何记录，刷新一下列表即可。 */
+        if (val) val.textContent = '重启';
+        if (ui && ui.btn) ui.btn.disabled = false;
+        loadSessions(true);
+        return;
+      }
+      if (val) val.textContent = '地址变了，正在重连…';
+      var list = loadConns(), changed = 0;
+      list.forEach(function (c) {
+        if (!c || !c.url) return;
+        /* 只换**与原入口同一个原点**的记录（当前这条 + 它的重复条目）。
+           ⚠️ 不按 eid 把同环境的所有入口一起换：同一台桌面的「公司本地 127.0.0.1」与
+           「公司远程 域名」共享 eid，但把回环入口也换成域名/局域网地址会把它弄坏 ——
+           那个入口在本机仍然有效（2026-10-25）。 */
+        if (normOrigin(c.url) !== oldOrigin) return;
+        var nu = swapOrigin(c.url, newOrigin);
+        if (!nu) return;
+        if (nu === c.url && String(c.token || '') === String(token || '')) return;
+        c.url = nu;
+        c.token = token || '';
+        c.id = connIdOf(c);
+        c.host = connHost(nu);
+        c.at = Date.now();
+        changed++;
+      });
+      saveConns(list);
+      var now = findConn(connIdOf({ url: r.base, token: token })) ||
+                findConn(connIdOf({ url: swapOrigin(connUrlNow(), newOrigin), token: token }));
+      if (!now) { fail('没能把新地址落成这条环境'); return; }
+      BASE = toConnValue(now.url);   // 同源页仍留空串（与 /desk/ 同源，见 apiOrigin）
+      TOKEN = now.token;
+      ACTIVE_ID = now.id;
+      try { localStorage.setItem(ACTIVE_ENV_KEY, now.url); } catch (e) {}
+      saveEnvScope(envScopeIdOf(now));   // 现场仍写在原环境（eid 没变）名下
+      /* 同源页（壳 / 远程界面）的令牌是**注入**进来的，首屏会认注入值。留下「接下来该用哪个
+         令牌」，首屏恢复时优先用它 —— 否则重载后又拿旧令牌去连，等于白换。 */
+      try {
+        sessionStorage.setItem('magic.remote.toknext.v1', JSON.stringify({ url: now.url, token: now.token }));
+      } catch (e) {}
+      toast('桌面端已重启，已把「' + (connLabel(now) || connHost(now.url)) + '」的地址与令牌刷新为 ' + now.host);
+      /* 通知轮询（tests/check-notify.mjs 钉着：每个给 BASE 赋值的分支都要起）。
+         现状：900ms 后整页重载，新页面首屏自己会起轮询；这里起一把是**兜底** ——
+         重载被壳拦住 / 失败时不至于连通知都停着（startPoll 幂等，不会起两套）。 */
+      ensureNotifyPoll();
+      setTimeout(function () {
+        try { location.reload(); } catch (e) { location.href = location.href; }
+      }, 900);   // 稍等一下再刷：让 toast 先被看见
+    }).catch(function (e) {
+      fail((e && e.message) ? e.message : String(e));
+    });
+  }
+
   /* ══════════ 接线 ══════════ */
   document.getElementById('btnConnect').onclick = function () {
     var target = parseTarget(addrEl.value);
@@ -8366,6 +10610,9 @@ html[data-theme="dark"] .tabfab__b{
          别名另开一个口子（getSpaceAlias），免得需求页去拆对象。 */
       getCustomSpaces: function () { return CUSTOM_SPACES.map(function (s) { return s.path; }); },
       getSpaceAlias: function (dir) { var it = customSpaceOf(dir); return it ? (it.alias || '') : ''; },
+      /* 被用户移除过的空间（2026-10-26）：需求页据此把这些空间整块滤掉 ——
+         与任务页「空间」分段同一口径（否则用户删了空间，需求页还留着它）。 */
+      isHiddenSpace: isHiddenSpace,
       getRunPref: function () { return RUN_PREF; },
       isRealSpaceDir: isRealSpaceDir,
       topLevelSessions: topLevelSessions,
@@ -8440,6 +10687,33 @@ html[data-theme="dark"] .tabfab__b{
       getToken: function () { return TOKEN; }
     });
   }
+  /* 应用页（apps.js）：与脚本页同一套注入方式 —— getter 传 BASE/TOKEN（切环境后会变），
+     抽屉借宿主的，「在内置浏览器打开」走 openBrowser（相对地址 = 本服务入口）。 */
+  if (window.MagicApps && window.MagicApps.mount) {
+    window.MagicApps.mount({
+      rootEl: appsEl,
+      detailEl: appDetailEl,
+      hEl: hEl,
+      elSpan: elSpan,
+      svgUse: svgUse,
+      toast: toast,
+      hideAll: hideAll,
+      setActive: setActive,
+      showRoot: function () {
+        hideAll();
+        appsEl.hidden = false;
+        tabbarEl.hidden = true;
+      },
+      showDetail: showAppDetail,
+      backToDiscover: showDiscover,
+      openSheet: openHostSheet,
+      closeSheet: closeHostSheet,
+      /* 应用工作台用专用入口（见 openAppInBrowser）：刷新 / 分享指回入口，而不是最后的 "/"。 */
+      openInBrowser: function (u) { openAppInBrowser(u); },
+      getBase: function () { return BASE; },
+      getToken: function () { return TOKEN; }
+    });
+  }
   Array.prototype.forEach.call(tabbarEl.querySelectorAll('.tab'), function (b) {
     b.onclick = function () {
       var t = b.getAttribute('data-tab');
@@ -8455,7 +10729,7 @@ html[data-theme="dark"] .tabfab__b{
   on('btnFabNew', function () { newConversation(); });
   on('btnMineBack', function () { showHistory(); });
   on('dscBrowser', function () { openBrowser(HOME_URL); });
-  on('dscApps', function () { openComingSheet('应用', '暂无可用应用。桌面端发布的应用会出现在这里。'); });
+  on('dscApps', function () { showApps(); });
   on('dscPlugins', function () { showPlugins(); });
   on('dscScripts', function () { showScripts(); });
   on('dscKnowledge', function () { showKnowledge(); });
@@ -8471,6 +10745,19 @@ html[data-theme="dark"] .tabfab__b{
   on('brHome', brHome);
   on('brRefresh', brReload);
   on('brShare', brShare);
+  /* 手动切换横屏：切过一次就不再自动判断（brLandByUser）。 */
+  on('brLand', function () { brSetLandscape(!brLand, true); });
+  if (brLandHint) {
+    var off = document.getElementById('brLandOff');
+    if (off) off.onclick = function () { brSetLandscape(false, true); };
+  }
+  /* 转屏 / 改窗口：设备横过来就撤回软件旋转（否则双重旋转），竖回去再自动判断。 */
+  window.addEventListener('resize', function () {
+    if (brEl.hidden) return;
+    if (brLand && window.innerWidth > window.innerHeight) { brSetLandscape(false); return; }
+    if (brLand) brSetLandscape(true);          // 舞台尺寸变了，重算铺满
+    else brScheduleLandscape();
+  });
   on('brStar', brToggleStar);
   on('brRelay', brToggleRelay);
   /* 截图按钮：需求页「页面完成情况」流程专用（reqshot.js 发指令、收图）。
@@ -8480,6 +10767,11 @@ html[data-theme="dark"] .tabfab__b{
   });
   brPaintRelay();
   on('btnNotify', openNotifySettings);
+  /* 飞书推送（2026-10-26）：「我的 → 账户 → 飞书推送」进子页面；返回回「我的」。 */
+  on('btnFeishuPage', showFeishuPage);
+  on('btnFeishuBack', showMine);
+  /* 「我的 → 账户 → 当前桌面」那一行右侧的「切换」：复用任务页标题的环境菜单（同一份清单）。 */
+  on('btnMineSwitchEnv', openEnvMenu);
   on('btnDefaultEngine', openDefaultEnginePicker);
   on('btnSuggestEngine', openSuggestEnginePicker);
   /* 团队模式配置（「我的」→ 子页面）：计划 + 7 个角色，行由 paintTeamRoles 动态渲染，
@@ -8617,6 +10909,15 @@ html[data-theme="dark"] .tabfab__b{
      · 其余情况：显示启动页，由用户粘贴/扫码连接。 */
   var injectedToken = window.MAGIC_TOKEN || new URLSearchParams(location.search).get('token') || '';
   var injectedBase = (window.MAGIC_BASE || '').replace(/\/+$/, '');
+  TOKEN_INJECTED = injectedToken;   // 见 apiToken：同源页的 BASE 为空时仍要带令牌
+  /* 重启 / 升级后跟着新实例换过令牌（见 followRestartMoved）：同源页的令牌是注入的，
+     这一轮恢复要用新令牌，并顺手撤掉这个一次性标记。 */
+  var TOKEN_OVERRIDE = null;
+  try {
+    var ov = JSON.parse(sessionStorage.getItem('magic.remote.toknext.v1') || 'null');
+    if (ov && ov.token) TOKEN_OVERRIDE = ov;
+    sessionStorage.removeItem('magic.remote.toknext.v1');
+  } catch (e) { TOKEN_OVERRIDE = null; }
   try {
     /* 上次停在哪个环境（见 switchEnv）：切过环境后整页重载，必须回到**那台**，
        否则壳注入的地址会把人拽回本机 —— 用户会看到「切了又跳回来」。 */
@@ -8631,14 +10932,27 @@ html[data-theme="dark"] .tabfab__b{
           var sc = saved[i];
           if (!sc || sc.url !== lastUrl) continue;
           /* 同一地址（壳注入的这台）令牌以注入为准：App 每次启动会换令牌，存档里的旧令牌已失效。 */
-          var tok = (lastUrl === injUrl && injectedToken)
-            ? injectedToken : (sc.token || injectedToken);
+          /* ⚠️ 例外：这份存档里的令牌与注入的不一样时，可能是「重启 / 升级后跟着新实例换过的
+             新令牌」（见 followRestartMoved）—— 能连上就用存档的，连不上再退回注入的，
+             否则一重载就被拽回已失效的旧令牌。 */
+          var tok = (lastUrl === injUrl && injectedToken && String(injectedToken) !== String(sc.token || ''))
+            ? (sc.token || injectedToken) : ((lastUrl === injUrl && injectedToken)
+              ? injectedToken : (sc.token || injectedToken));
           if (!tok) break;
           BASE = sc.url; TOKEN = tok;
           sc = ensureEnvId(sc) || sc;   // 老记录补 eid，并把按地址分区的旧队列/配置槽迁过来
           ACTIVE_ID = sc.id;
+          /* 换过令牌后 id 会按 url|token 重算：存档是按旧令牌存的，这时 ACTIVE_ID 对不上。
+             统一从「这一次真正要连的」连接里取（没变的记录 id 相同，行为不变）。 */
+          /* 换过令牌的那一轮（见 followRestartMoved）：先撤掉注入的旧令牌，再按 eid / 新令牌认这条，
+             否则 ACTIVE_ID 会停在按 url|旧令牌 算出来的那行上。 */
+          if (TOKEN_OVERRIDE) TOKEN = '';
+          var bound = keepSameConn(TOKEN_OVERRIDE ? TOKEN_OVERRIDE.url : '')
+                   || findConn(connIdOf({ url: BASE, token: TOKEN }));
+          if (bound) { BASE = bound.url; TOKEN = bound.token; ACTIVE_ID = bound.id; }
           showHistory(sc.host || connHost(sc.url));
           restoreQueue();
+          ensureNotifyPoll();   // 通知轮询（见 ensureNotifyPoll：这条路径原先从不启动）
           resumed = true;
           break;
         }
@@ -8652,6 +10966,7 @@ html[data-theme="dark"] .tabfab__b{
       ensureEnvId(activeConn());   // 种出来的这条也补 eid；seedoff 没落盘时按老键回退
       showHistory(injectedBase ? injectedBase.replace(/^https?:\/\//, '') : '本机');
       restoreQueue();      // App 重启：上次没轮到的排队任务接着排（见 restoreQueue）
+      ensureNotifyPoll();  // 通知轮询（见 ensureNotifyPoll：这条路径原先从不启动）
     } else if (!resumed) {
       /* 没有注入、也没有可恢复的上次环境：有存过的环境就直接连最近用过的那条；
          一条都没有才进任务页空态 —— 不再用独立启动页挡在前面
@@ -8665,6 +10980,7 @@ html[data-theme="dark"] .tabfab__b{
         try { localStorage.setItem(ACTIVE_ENV_KEY, pick.url); } catch (e) {}
         showHistory(pick.host || connHost(pick.url));
         restoreQueue();
+        ensureNotifyPoll();  // 通知轮询（见 ensureNotifyPoll：这条路径原先从不启动）
       } else {
         showHistory(null);
       }