magic-agent 1.0.111 → 2.1.5

package/client-ui-mobile/index.html

@@ -206,6 +206,10 @@ textarea{font:inherit}
 .field label{display:block;font-size:12px;font-weight:500;color:var(--muted);margin-bottom:4px}
 .field textarea{display:block;width:100%;border:0;outline:0;resize:none;background:none;
   color:var(--ink);font:15px/20px var(--mono);min-height:40px}
+/* 名称栏（2026-10-22 用户：「添加连接也没有输入名字的地方」）：单行输入，与地址栏同样式 */
+.field input{display:block;width:100%;height:40px;border:0;outline:0;background:none;
+  color:var(--ink);font-family:inherit;font-size:15px;line-height:20px;-webkit-appearance:none}
+.field+.field{margin-top:12px}
 .field__err{color:var(--error-text);font-size:12px;line-height:16px;margin-top:6px}
 /* Button（filled）/ OutlinedButton：40dp 高 · 全圆角 */
 .btn{display:flex;align-items:center;justify-content:center;gap:8px;width:100%;height:40px;
@@ -361,6 +365,12 @@ textarea{font:inherit}
 .wsrow__open{flex:1;display:flex;align-items:center;gap:12px;min-width:0;padding:10px 8px;border-radius:14px;text-align:left}
 .wsrow__open:active{background:var(--subtle)}
 .wsrow__l{flex:1;min-width:0;font-size:15px;color:var(--ink);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+/* 空间规模（几模块 · 几条）：紧跟在空间名后面，中性色 —— 不是状态，别用徽标色。
+   需求页专属：空间名改成自适应宽度，meta 才会贴在名字后面；meta 的 margin-right:auto
+   把「待整理」徽标和箭头推到行尾。 */
+.wsrow__open--req .wsrow__l{flex:0 1 auto}
+.wsrow__open--req .wsrow__meta{margin-right:auto}
+.wsrow__meta{flex:0 1 auto;min-width:0;font-size:12px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
 /* 串行等待中的任务数：空间组折叠时也要看得见（颜色与「等待中」行一致） */
 .wsrow__badge{flex:0 0 auto;padding:1px 7px;border-radius:var(--r-full);font-size:11px;line-height:16px;
   color:var(--queued);background:var(--tint-queued);white-space:nowrap}
@@ -377,6 +387,24 @@ textarea{font:inherit}
 /* 「未初始化」与「待整理」同形不同色：前者是「还没按目录生成过基线」，
    后者是「有对话等着归纳」，两种提示不能混成一个数字。 */
 .wsrow__badge--init{color:var(--warning);background:var(--tint-wait)}
+
+/* ══════════ 需求页：两级（空间→模块 → 需求列表）══════════
+   一级是**目录**：空间是行，模块缩进挂在空间下（树形），功能点一律不画在这里 ——
+   需求一多，一级就会被功能点撑成长列表，什么结构都看不出来。
+   二级才是内容：点某个模块进去，看**该空间下所有模块**的需求列表。 */
+.reqtree__mod{position:relative;display:flex;align-items:center;gap:8px;width:100%;
+  padding:9px 10px 9px 30px;background:none;border:0;text-align:left;color:var(--ink)}
+.reqtree__mod:active{background:var(--subtle)}
+/* 连接线：从空间名垂下来的细线 + 每个模块前的一小截横线 —— 归属关系靠线说话，不靠缩进猜 */
+.reqtree__mod::before{content:"";position:absolute;left:14px;top:0;bottom:0;width:1px;background:var(--border)}
+.reqtree__mod::after{content:"";position:absolute;left:14px;top:50%;width:10px;height:1px;background:var(--border)}
+.reqtree__modname{flex:1;min-width:0;font-size:14px;font-weight:500;color:var(--ink);
+  overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.reqtree__modcount{flex:0 0 auto;font-size:12px;color:var(--muted);font-variant-numeric:tabular-nums}
+.reqtree__modgo{flex:0 0 auto;color:var(--faint);display:flex;align-items:center}
+/* 二级视图的分组小节：当前所在模块高亮，其余弱化 */
+.reqdetail__sec--cur .sechead{color:var(--primary-action)}
+.reqdetail__sec--cur .sechead__t{font-weight:800}
 /* 长按会话行的浮动菜单 */
 .rowmenu{position:fixed;z-index:1201;min-width:184px;background:var(--raised);border:1px solid var(--border);
   border-radius:14px;box-shadow:0 14px 34px -12px var(--app-shadow);padding:6px}
@@ -405,7 +433,13 @@ textarea{font:inherit}
   font-size:11px;font-weight:600;line-height:17px;color:var(--primary-action);background:var(--subtle)}
 .envmenu__s{font-size:12px;line-height:16px;color:var(--muted);
   white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.envmenu__check{flex:0 0 auto;color:var(--primary-action)}
+/* 当前连接用**底色**区分，不再挂一枚 ✓（2026-10-22 用户：「不需要选中这个标识 用底色区分」）。
+   底色要能压过同一行的 :active 态，所以写在它后面。 */
+.envmenu__item.is-active{background:var(--subtle)}
+/* 每行的修改入口：铅笔比「›」更明确是「编辑」，且不与整行的「切换」动作打架 */
+.envmenu__edit{flex:0 0 auto;width:36px;height:36px;border-radius:50%;
+  display:flex;align-items:center;justify-content:center;color:var(--muted)}
+.envmenu__edit:active{background:var(--subtle);color:var(--ink)}
 .envmenu__sep{display:block;height:1px;margin:6px 4px;background:var(--border)}
 .envmenu__add{display:flex;align-items:center;gap:10px;width:100%;padding:12px;border-radius:12px;
   font-size:15px;font-weight:500;color:var(--primary-action);text-align:left}
@@ -462,6 +496,8 @@ button.setrow{font-family:inherit}
 .setrow+.setrow{border-top:1px solid var(--border)}
 .setrow__l{flex:1;min-width:0;font-size:15px;color:var(--ink)}
 .setrow__v{flex:0 0 auto;font-size:14px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:50%}
+/* 有新版本时这一格变成可点的「升级」提示（2026-10-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)}
 /* 环境编辑（我的 → 环境）：名称 / 地址 / 令牌三栏。
@@ -472,6 +508,8 @@ button.setrow{font-family:inherit}
 .envfield:focus{border-color:var(--primary-action)}
 .envfield::placeholder{color:var(--faint)}
 .envlabel{display:block;margin-top:14px;font-size:12px;font-weight:700;color:var(--muted)}
+/* 链接栏下方的「扫码填入」：文字按钮，不抢「保存」的位置 */
+.envscan{display:block;margin-top:8px;padding:6px 0;font-size:13px;font-weight:600;color:var(--primary-action)}
 .envhint{margin-top:10px;font-size:12px;line-height:1.6;color:var(--faint)}
 .envacts{display:flex;gap:8px;margin-top:16px}
 .envacts .btn{flex:1;margin-top:0}
@@ -491,6 +529,14 @@ button.setrow{font-family:inherit}
 .teamedit__acts{display:flex;gap:8px;margin-bottom:10px}
 /* 团队行尾箭头：点开才有的配置必须看得出「这里能点」。 */
 .setrow__chev{flex:0 0 auto;color:var(--faint);font-size:16px;line-height:1}
+/* 团队行 = **一行两个点击区**（用户 2026-10-22：「两个触发就行了」）：
+   左边名字 + 规则描述 → 只改规则；右边引擎值 → 只选引擎。外层是 div（button 不能套 button）。 */
+.setrow--split{padding:0;gap:4px}
+.setrow__mainbtn{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px;
+  padding:14px 2px 14px 0;text-align:left}
+.setrow__vbtn{flex:0 0 auto;display:flex;align-items:center;gap:4px;max-width:52%;
+  padding:14px 0 14px 10px;color:var(--muted);text-align:right}
+.setrow__vbtn .setrow__v{max-width:100%}
 .seg{display:inline-flex;background:var(--subtle);border-radius:var(--r-full);padding:2px;gap:2px}
 .seg__b{height:28px;padding:0 12px;border-radius:var(--r-full);font-size:13px;color:var(--muted)}
 .seg__b.is-on{background:var(--raised);color:var(--ink);font-weight:600}
@@ -505,18 +551,20 @@ button.setrow{font-family:inherit}
    从栏背滚过去，靠半透明 + 18px 模糊透出来。这样栏高不进布局，会话页的输入框也不用被它顶上去。
 
    代价是**每一页自己留出底部安全距离**，否则最后一行会被压在栏下面：
-     · `.history__list` 已有 96px（够 74 + 34 safe-area）
+     · `.history__list` 已有 96px（够 56 + 34 safe-area，且给凸出的 ＋ 留了一截）
      · 会话页由 composer 的下内边距负责，见下面的 `#conv .composer`
      · 启动页不显示底栏（showLauncher 里 hidden），无需留白
 
    min-height 而不是 height：底栏还要吞 safe-area（34px），
    border-box 下固定 height 会让内部 tab 被压到 26px 高。
-   **56**（2026-10-22 定稿「底栏只保留图标不需要文字了」）：
-   去掉标签后只剩 25px 图标 + 44×34 选中浅底，56 给到浅底上下各 11px，
-   栏体也矮下来 —— 对话区因此多出 18px。 */
+   **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，栏体也矮下来。 */
 .tabbar{position:absolute;left:0;right:0;bottom:0;z-index:60;
   display:flex;align-items:stretch;
-  min-height:56px;
+  min-height:calc(56px + env(safe-area-inset-bottom));
   background:color-mix(in srgb,var(--raised) 86%,transparent);
   -webkit-backdrop-filter:blur(18px) saturate(1.4);backdrop-filter:blur(18px) saturate(1.4);
   box-shadow:0 -1px 0 var(--border),0 -14px 30px -26px var(--app-shadow);
@@ -548,15 +596,16 @@ button.setrow{font-family:inherit}
    于是看起来像按钮自带发光轮廓。
 
    实现：
-     ① **洞**：`::before` 是一块悬在栏顶边界内的半圆（宽 74 / 高 37，下两角半径 37），
-        填槽底 `--fab-well`，在底栏上边缘切出一个半圆缺口。
-        高度只到 37，**不侵入上方内容**（试过整圆深度，会盖住列表底部）。
-     ② **嵌**：按钮直径 68，圆心落在栏顶边线上（上露 34 / 下沉 34），
-        于是下半实打实坐进洞里。圆心压边线而不是抬高，是「嵌」与「放」的分界。
+     ① **洞**：`::before` 是一块 74×74 的圆（半径 37 = 按钮 34 + 3 接触缝），圆心与按钮同心，
+        **再用 `clip-path` 切掉落在栏顶边线以上的部分** —— 这样槽的形状永远跟着按钮走，
+        按钮下沉多少，露出的就是那一段圆弧，不用为每种下沉量另算半圆尺寸。
+        填槽底 `--fab-well`，于是在底栏上边缘切出一道弧。
+     ② **嵌**：按钮直径 68，圆心落在栏顶边线**下方 10px**（上露 24 / 下沉 44，距栏底还剩 12）。
+        不是齐边切一半（2026-10-22 用户：「不需要突出半圆 出来一部分即可 再下沉一些 注意保留间距」）。
      ③ **接触影**：`radial-gradient` 把暗环**锚定在 r=34（按钮半径）**上，
-        从 33.5px 起最暗、到 37px 淡完。这是唯一能精确控制「暗在哪一圈」的写法 ——
+        从 33.5px 起最暗、到 37px 淡完，圆心同样与按钮同心。这是唯一能精确控制「暗在哪一圈」的写法 ——
         `box-shadow: inset` 的暗边永远从元素边界向内，管不到元素外的那道槽。
-   几何全用相对量（`bottom:calc(100% - 34px)`、`top:0`），安全区变化时洞和按钮一起走。
+   几何全用相对量（`bottom:calc(100% - 44px)`、`top:-27px`），安全区变化时洞和按钮一起走。
 
    **两页一致**：会话页不再把「＋」收进栏内（2026-10-22 用户：「圆没有突出了 …两个效果要一致」）。
    凸出的圆在列表页和对话页长得完全一样，只用 composer 的下内边距给它让出空间。 */
@@ -567,22 +616,21 @@ button.setrow{font-family:inherit}
    接触影必须画在槽底**之上**，且暗环两端用硬锚点，
    避免模糊半径把亮度峰值推到按钮外面（那正是前几版读成光晕的原因）。
 
-   **露出的槽宽只有 3px**（洞半径 37 − 按钮半径 34）。曾经用更大：那圈灰色槽底读作「按钮下面垫了个盘子」，
-   正是用户否掉的形态。3px 只够出一条接触缝 —— 看得见槽、看不清槽底，就等于"切出来的"。
-   洞的高也取 37 而不是更深：槽只要在栏顶边界内切出缺口，深了只是浪费。 */
+   **露出的槽宽只有 3px**（槽半径 37 − 按钮半径 34）。曾经用更大：那圈灰色槽底读作「按钮下面垫了个盘子」，
+   正是用户否掉的形态。3px 只够出一条接触缝 —— 看得见槽、看不清槽底，就等于"切出来的"。 */
 .tabbar::before{content:"";position:absolute;z-index:1;pointer-events:none;
-  left:50%;top:0;transform:translateX(-50%);
-  width:74px;height:37px;
-  border-radius:0 0 37px 37px;
+  left:50%;top:-27px;transform:translateX(-50%);
+  width:74px;height:74px;border-radius:50%;
+  clip-path:inset(27px 0 0 0);          /* 圆心在栏顶下方 10px：切掉露在外面的那一截，只留栏内的弧 */
   background:
-    radial-gradient(circle 37px at 50% 0,
+    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),
     var(--fab-well)}
 .tabfab__b{position:absolute;z-index:2;
-  left:50%;bottom:calc(100% - 34px);              /* 圆心钉在栏顶边线上：上露 34 / 下沉 34 */
+  left:50%;bottom:calc(100% - 44px);              /* 上露 24 / 下沉 44，距栏底 12 */
   transform:translateX(-50%);
   width:68px;height:68px;
   display:flex;align-items:center;justify-content:center;
@@ -597,14 +645,14 @@ button.setrow{font-family:inherit}
 .tabfab__b:active{transform:translateX(-50%) translateY(2px);
   box-shadow:inset 0 -6px 12px -7px rgba(15,23,42,.56), inset 0 2px 3px -2px rgba(255,255,255,.26)}
 .tabfab__b svg{display:block;stroke-width:2.4;transform:translateY(-1px)}
-/* 会话页（2026-10-22 用户：「不要挤压对话框」「两个效果要一致」「圆可以更大」）：
-   底栏浮起后不占位，「＋」在**两页都凸出 34**（68 直径的一半），所以 composer 只需让出
-   「上探 34 + 呼吸 12 + 栏高 56」—— 输入框落在凸出圆的头顶 12px，不遮不压。
+/* 会话页（2026-10-22 用户：「不要挤压对话框」「两个效果要一致」「圆可以更大」「再下沉一些 注意保留间距」）：
+   底栏浮起后不占位，「＋」在**两页都上露 24**（68 直径、圆心在栏顶下方 10），所以 composer 只需让出
+   「上露 24 + 呼吸 12 + 栏高 56」—— 输入框落在凸出圆弧上方 12px，不遮不压。
    原来 composer 下留 60（= 上探 30 + 呼吸 30）再叠占位的 68 栏，屏幕底到输入框 162；
-   现在 56 + 34 + 12 = 102，对话区多出 60px。
-   56 必须与 .tabbar 的 min-height 对齐（改栏高要一起改）。
+   现在 56 + 24 + 12 = 92，对话区多出 70px。
+   56 必须与 .tabbar 的 min-height 对齐、24 必须与 .tabfab__b 的下沉量对齐（改一处要一起改）。
    **只叠一次**：safe-area 由这里一次性算进来，别再给 .composer 的基础 padding 加一遍。 */
-#conv .composer{padding-bottom:calc(12px + 34px + 56px + env(safe-area-inset-bottom))}
+#conv .composer{padding-bottom:calc(12px + 24px + 56px + env(safe-area-inset-bottom))}
 
 /* 组件挂载点：占满剩余高度 */
 #conv{flex:1;min-height:0;display:flex}
@@ -852,8 +900,13 @@ button.setrow{font-family:inherit}
     <svg width="18" height="18"><use href="#i-back"/></svg><span>返回</span>
   </button>
   <h1 class="launcher__title">magic-agent · 远程控制</h1>
-  <p class="launcher__desc">打开桌面配对页里的连接地址，远程继续你的会话。</p>
+  <p class="launcher__desc">填一个名字和桌面地址，或扫码配对。连过的桌面会保存下来，可在任务页标题处切换。</p>
 
+  <div class="field" id="nameField">
+    <label for="connName">名称（可选）</label>
+    <input id="connName" type="text" placeholder="例如 公司 Mac"
+      autocomplete="off" autocapitalize="off" spellcheck="false">
+  </div>
   <div class="field" id="field">
     <label for="addr">桌面地址</label>
     <textarea id="addr" rows="2" placeholder="http://192.168.1.5:8791/?token=…"
@@ -911,8 +964,6 @@ button.setrow{font-family:inherit}
   <div class="history__list">
     <div class="setcard">
       <div class="setrow"><span class="setrow__l">设备</span><span class="setrow__v" id="mineDevice">—</span></div>
-      <!-- 环境（多连接）：显式配置每台桌面的名字 / IP / 令牌，并在这里切换 -->
-      <button class="setrow" id="btnEnvPage"><span class="setrow__l">环境</span><span class="setrow__v" id="mineEnv">—</span></button>
       <div class="setrow"><span class="setrow__l">主题</span>
         <span class="seg" id="segTheme">
           <button class="seg__b" data-v="system">系统</button>
@@ -949,12 +1000,15 @@ button.setrow{font-family:inherit}
       <button class="setrow" id="btnTeamPage"><span class="setrow__l">团队模式</span><span class="setrow__v" id="teamSummary">跟随主引擎</span></button>
     </div>
     <div class="setcard">
-      <!-- 版本号（2026-10-22 用户：「移动端我的tab中显示版本号」）。
-           值由 /desk/health 的 version 给（= core 的 `--version`）—— 移动端界面是
-           桌面端 /m/ 远程加载的、本身不带版本，用户要看的是「连着的这份是哪一版」。
-           老 core 不给 version 时保持「—」，不写死。 -->
-      <div class="setrow"><span class="setrow__l">版本</span><span class="setrow__v" id="mineVersion">—</span></div>
-      <button class="setrow" id="btnUpgrade"><span class="setrow__l">检查更新</span><span class="setrow__v" id="upgradeState">重新加载</span></button>
+      <!-- 版本号 + 升级（2026-10-22 用户：「移动端版本跟着npm走」+「在版本号的地方
+           可以显示版本也可检测最新版本号并触发升级」）。
+           显示的是 **APK 自己的版本**（构建时从 magic-agent/package.json 注入，闸门页
+           通过 ?appv= 带进来）；浏览器预览没有 appv 时才回落到桌面端 health.version。
+           点这一行就去问桌面端内置的 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>
     </div>
     <div class="setcard">
       <button class="setrow setrow--danger" id="btnLogout">断开连接</button>
@@ -966,40 +1020,18 @@ button.setrow{font-family:inherit}
      从「我的」那一行点进来。这里配的全都是**设备级偏好**（开关本身按会话，在会话页运行设置里）。
      **只有一套划分**：计划 + 7 个角色（writer / researcher / reviewer / coder / designer /
      director / builder），不再并列「6 个类别」那一层。
-     2026-10-22 用户：「配引擎和配规则要分开配置 不要在 1 个页面」——
-     于是**两张卡、两个入口**：上面「交给谁」点开只有引擎/模型；下面「规则」点开只有规则
-     （计划 = 拆解口径，角色 = 这类任务适合什么）。两者互不掺杂。 -->
+     2026-10-22 用户：「两个触发就行了」—— 一行里**两个点击区**：
+     左边（名字 + 规则描述）点开只改规则；右边（引擎值）点开只选引擎。
+     不拆两张卡，也不把规则和引擎塞进同一个抽屉。 -->
 <div class="history" id="teamPage" hidden>
   <div class="history__top">
     <button class="topbar__icon" id="btnTeamBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
     <span class="history__title">团队模式</span>
   </div>
   <div class="history__list">
-    <div class="history__group">交给谁（引擎 / 模型）</div>
+    <div class="history__group">计划与 7 类子任务</div>
     <div class="setcard" id="teamRouteCard"></div>
-    <div class="history__group">规则（只影响计划怎么拆）</div>
-    <div class="setcard" id="teamRuleCard"></div>
-    <div class="history__hint" style="text-align:left">两张卡分开配：上面只选引擎，下面只改规则。留空 = 跟随主引擎 / 使用内置规则。</div>
-  </div>
-</div>
-
-<!-- ══════════ 我的 → 环境（多连接：名字 / IP / 令牌）══════════
-     2026-10-22 用户：「环境没有地方配置 ip 和名字啊」。
-     环境不能只靠「连过才记得」：这里显式新建 / 改名 / 改地址 / 删，点一行就编辑。
-     地址填 IP:端口即可（不带 http:// 自动补），令牌可以写在地址的 ?token= 里，
-     也可以单独填下面那栏（显式令牌优先）。 -->
-<div class="history" id="envPage" hidden>
-  <div class="history__top">
-    <button class="topbar__icon" id="btnEnvBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
-    <span class="history__title">环境</span>
-  </div>
-  <div class="history__list">
-    <div class="history__group">已配置的桌面</div>
-    <div class="setcard" id="envList"></div>
-    <div class="history__actions" style="padding:10px 0 0">
-      <button class="newtask" id="btnEnvAdd" type="button"><svg width="18" height="18"><use href="#i-plus"/></svg><span>新建环境</span></button>
-    </div>
-    <div class="history__hint" style="text-align:left">环境 = 一台跑着 magic-client 的桌面。名字随你起（例如「公司 Mac」），地址填 IP:端口，例如 192.168.1.5:8791。保存后可在这里或任务页标题处切换。</div>
+    <div class="history__hint" style="text-align:left">左边点规则，右边点引擎。规则留空 = 内置规则；引擎留空 = 跟随主引擎。</div>
   </div>
 </div>
 
@@ -1023,7 +1055,10 @@ button.setrow{font-family:inherit}
 
 <!-- ══════════ 需求（会话自动聚合成的功能点文档）══════════
      数据全来自 GET /desk/requirements（core 的 --requirements，只读）。
-     按「工作区 → 模块 → 功能点」两级分组；点一行用既有的阅读器打开那篇 markdown。
+     **两级**（2026-10-22 用户定稿）：
+       一级 = 目录（空间 → 模块），**不画功能点** —— 一级只回答「这个空间有哪几块」；
+       二级 = 点某个模块进去，看**该空间下所有模块**的需求列表（当前模块高亮）。
+     点一行用既有的阅读器打开那篇 markdown。
      ⚠️ 这里**不做筛选胶囊与搜索**：第一版只要「看得见 + 能点开」，多了反而没人用
         （用户 2026-10-22 定稿）。 -->
 <div class="history" id="reqs" hidden>
@@ -1034,6 +1069,16 @@ button.setrow{font-family:inherit}
   <div class="history__list" id="reqList"></div>
 </div>
 
+<!-- 需求的二级视图：某空间下所有模块的需求列表（从一级目录点模块进来） -->
+<div class="history" id="reqDetail" hidden>
+  <div class="history__top">
+    <button class="topbar__icon" id="btnReqDetailBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>
+    <span class="history__title" id="reqDetailTitle">需求</span>
+    <button class="history__disconnect" id="btnReqDetailSync" type="button">整理</button>
+  </div>
+  <div class="history__list" id="reqDetailList"></div>
+</div>
+
 <!-- ══════════ 发现（浏览器 / 应用 / 插件 / SKILL）══════════ -->
 <div class="history" id="discover" hidden>
   <div class="history__top"><span class="history__title">发现</span></div>
@@ -1204,6 +1249,7 @@ button.setrow{font-family:inherit}
   var subtitleEl = document.getElementById('subtitle');
   var fieldEl = document.getElementById('field');
   var addrEl = document.getElementById('addr');
+  var connNameEl = document.getElementById('connName');
   var errEl = document.getElementById('err');
   var recentEl = document.getElementById('recent');
   var recentListEl = document.getElementById('recentList');
@@ -1216,9 +1262,6 @@ button.setrow{font-family:inherit}
   var taskSearchInput = document.getElementById('taskSearchInput');
   var mineEl = document.getElementById('mine');
   var mineDevice = document.getElementById('mineDevice');
-  var mineEnv = document.getElementById('mineEnv');
-  var envPageEl = document.getElementById('envPage');
-  var envListEl = document.getElementById('envList');
   var mineVersion = document.getElementById('mineVersion');
   var segTheme = document.getElementById('segTheme');
   var segFont = document.getElementById('segFont');
@@ -1227,6 +1270,9 @@ button.setrow{font-family:inherit}
   var tabbarEl = document.getElementById('tabbar');
   var reqsEl = document.getElementById('reqs');
   var reqListEl = document.getElementById('reqList');
+  var reqDetailEl = document.getElementById('reqDetail');
+  var reqDetailTitle = document.getElementById('reqDetailTitle');
+  var reqDetailListEl = document.getElementById('reqDetailList');
   var discoverEl = document.getElementById('discover');
   var teamPageEl = document.getElementById('teamPage');
   var runSettingsPageEl = document.getElementById('runSettingsPage');
@@ -1259,7 +1305,7 @@ button.setrow{font-family:inherit}
   /* 工作空间要跨重启记住（与引擎 / 模型同一口径）：只放内存的话，App 重启后
      「任务运行设置」里选的空间就回到默认，用户会以为没保存。 */
   try { WS = localStorage.getItem('magic.ws') || ''; } catch (e) {}
-  function saveWs() { try { localStorage.setItem('magic.ws', WS || ''); } catch (e) {} }
+  function saveWs() { try { localStorage.setItem('magic.ws', WS || ''); } catch (e) {} schedulePushPrefs(); }
   /* 默认引擎 / 模型（「我的」可改；函数与选择器见下面「默认引擎 / 模型」段）。
      提前到这里声明：首屏 paintRunPref 会读它，晚于 PREFS 初始化赋值就会踩 undefined。 */
   var RUN_PREF = loadRunPref();
@@ -1366,6 +1412,7 @@ button.setrow{font-family:inherit}
     try { localStorage.setItem('magic.team.split', TEAM.split || 'standard'); } catch (e) {}
     try { localStorage.setItem('magic.team.splitcode', TEAM.splitCode ? '1' : '0'); } catch (e) {}
     try { localStorage.setItem('magic.team.adaptive', TEAM.adaptive === false ? '0' : '1'); } catch (e) {}
+    schedulePushPrefs();
     paintTeamPref();
   }
   /* 这条会话的开关：本地记过就用本地；没记过 → 跟会话自己的运行模式（core 的 `mode:"team"`）。
@@ -1394,6 +1441,21 @@ button.setrow{font-family:inherit}
   var LS_KEY = 'magic.remote.recent.v1';   // 旧版「最近连接」：只在首次升级时搬一次
   var ACTIVE_ID = '';
   var CONN_SEQ = 0;        // 每连一次 +1：上一台桌面迟到的响应不许画到这一台上面
+  /* APK 自己的版本（2026-10-22）：闸门页从构建时注入的版本号带进来（?appv=）。
+     为什么接口里还要 SERVER_VERSION：浏览器预览 / 旧版闸门页没有 appv，此时只能显示
+     连着的桌面端版本；两个都有时以 App 版本为准（用户问的「移动端版本」）。 */
+  var APP_VERSION = (function () {
+    try {
+      var v = new URL(location.href).searchParams.get('appv');
+      if (v && /^\d+\.\d+\.\d+$/.test(v)) return v;
+    } catch (e) {}
+    /* 兜底：本地 ui.html（桌面端没有 /m/ 时）由 boot.js 注入。 */
+    try {
+      var b = String(window.MAGIC_APP_VERSION || '');
+      if (/^\d+\.\d+\.\d+$/.test(b)) return b;
+    } catch (e) {}
+    return '';
+  })();
 
   function connHost(url) {
     try { return new URL(url).host; }
@@ -1438,28 +1500,44 @@ button.setrow{font-family:inherit}
     var next = {
       id: id, url: t.url || '', token: t.token || '',
       name: (t.name != null && t.name !== '') ? t.name : (old.name || ''),
-      host: connHost(t.url), app: old.app || '', at: Date.now()
+      host: connHost(t.url), app: old.app || '', at: Date.now(),
+      seed: !!old.seed      // 种出来的默认环境：改名/改地址后仍然认出它
     };
     list.unshift(next);
     saveConns(list);
     return next;
   }
-  function removeConn(id) { saveConns(loadConns().filter(function (c) { return c.id !== id; })); }
+  function removeConn(id) {
+    var list = loadConns();
+    var hit = null;
+    list.forEach(function (c) { if (c && c.id === id) hit = c; });
+    /* 用户主动删掉种出来的默认环境：记一笔，下次启动别再自动加回来。 */
+    if (hit && hit.seed) { try { localStorage.setItem('magic.remote.seedoff.v1', '1'); } catch (e) {} }
+    saveConns(list.filter(function (c) { return c.id !== id; }));
+  }
   function clearConns() {
     saveConns([]);
-    try { localStorage.removeItem(LS_KEY); } catch (e) {}
+    try {
+      localStorage.removeItem(LS_KEY);
+      localStorage.setItem('magic.remote.seedoff.v1', '1');   // 清空 = 明确不要默认环境
+    } catch (e) {}
   }
 
   /* 当前连接：先按地址 + 令牌找；App 壳注入的连接还没落盘时给一条临时记录，
-     这样标题与菜单里仍然看得见「现在连的是谁」。 */
+     这样标题与菜单里仍然看得见「现在连的是谁」。
+     ⚠️ 壳里 BASE 可能是空串（同源）：这时用 location.origin 当它的地址 ——
+        否则这条「未命名」没有 URL，既存不下来也就没法编辑（2026-10-22 用户：
+        「现在已有的未命名都编辑不了」）。 */
+  function connUrlNow() { return BASE || (TOKEN ? location.origin : ''); }
   function activeConn() {
+    var url = connUrlNow();
     var list = loadConns(), i;
     for (i = 0; i < list.length; i++) {
-      if (list[i].url === BASE && String(list[i].token || '') === String(TOKEN || '')) return list[i];
+      if (list[i].url === url && String(list[i].token || '') === String(TOKEN || '')) return list[i];
     }
     for (i = 0; i < list.length; i++) if (ACTIVE_ID && list[i].id === ACTIVE_ID) return list[i];
-    if (BASE || TOKEN) {
-      return { id: connIdOf({ url: BASE, token: TOKEN }), url: BASE, token: TOKEN, name: '', host: connHost(BASE), app: '' };
+    if (url || TOKEN) {
+      return { id: connIdOf({ url: url, token: TOKEN }), url: url, token: TOKEN, name: '', host: connHost(url), app: '' };
     }
     return null;
   }
@@ -1468,7 +1546,219 @@ button.setrow{font-family:inherit}
     if (!c) return '';
     return c.name || c.app || c.host || connHost(c.url);
   }
-  function envLabel() { return connLabel(activeConn()) || histSubtitle || ''; }
+  function envLabel() {
+    var c = activeConn();
+    if (!c) return histSubtitle || '';
+    /* 壳注入的同源连接（还没有名字）：标题仍显示「本机」，别把 127.0.0.1:端口 顶到标题上。 */
+    if (!c.name && !c.app && String(c.url) === String(location.origin)) return histSubtitle || '本机';
+    return connLabel(c) || histSubtitle || '';
+  }
+
+  /* ── 默认环境：把「当前正在用的这条连接」落成一条可编辑的环境 ──
+     2026-10-22 用户：「再添加一个现在远程的地址，名字就叫公司远程」。
+     壳注入的连接（URL 里的 ?token=）如果不落盘，列表里就只有一条「未命名」的临时记录，
+     既改不了名也留不住。这里在首屏把它存成环境：本机回环叫「公司本地」，
+     局域网地址叫「公司远程」，都可在铅笔里改。
+     ⚠️ App 每次启动会换令牌：按 seed 标记 + 地址更新那一条，不要每次多出一条。 */
+  var SEED_NAME = '公司远程';
+  var SEED_LOCAL = '公司本地';
+  function isLoopUrl(u) {
+    try {
+      var h = String(u || '');
+      return /^https?:\/\/(127\.|localhost|\[::1\]|0\.0\.0\.0)/i.test(h);
+    } catch (e) { return false; }
+  }
+  function seedMark(rec) {
+    var l2 = loadConns();
+    for (var j = 0; j < l2.length; j++) if (l2[j].id === rec.id) l2[j].seed = true;
+    saveConns(l2);
+  }
+  function seedCurrentConn() {
+    var url = connUrlNow();
+    if (!url || !TOKEN) return;
+    try { if (localStorage.getItem('magic.remote.seedoff.v1') === '1') return; } catch (e) {}
+    var name = isLoopUrl(url) ? SEED_LOCAL : SEED_NAME;
+    var list = loadConns();
+    for (var i = 0; i < list.length; i++) {
+      var c = list[i];
+      if (!c) continue;
+      if (c.url === url && String(c.token || '') === String(TOKEN || '')) {
+        /* 早先版本把回环连接也叫「公司远程」（同地址种子没带名字）：按地址纠正，
+           但不碰用户自己改过的名字。 */
+        if (c.seed && isLoopUrl(url) && c.name === SEED_NAME) { c.name = SEED_LOCAL; saveConns(list); }
+        return;   // 已经有这条
+      }
+      if (c.seed && c.url === url) {
+        c.token = TOKEN;
+        c.id = connIdOf({ url: url, token: TOKEN });
+        c.at = Date.now();
+        saveConns(list);
+        return;
+      }
+    }
+    seedMark(upsertConn({ url: url, token: TOKEN, name: name }));
+  }
+  /* 桌面 health 上报的远程入口：优先公网（cloudflared，不在同一 Wi-Fi 也能连），
+     没有再退回局域网。用户不用手抄地址。同地址只留一条；令牌跟着当前连接走。 */
+  function seedRemoteConns(urls) {
+    if (!urls || !urls.length || !TOKEN) return;
+    try { if (localStorage.getItem('magic.remote.seedoff.v1') === '1') return; } catch (e) {}
+    var url = String(urls[0] || '').replace(/\/+$/, '');
+    if (!url) return;
+    if (url === String(connUrlNow()).replace(/\/+$/, '')) return;
+    var list = loadConns();
+    /* 隧道换域名（cloudflared 每次重启都换）：把上一枚**默认命名**的种子远程记录换到新地址。
+       用户改过名字的不动 —— 那条是他自己配的环境。 */
+    var kept = [];
+    for (var k = 0; k < list.length; k++) {
+      var o = list[k];
+      if (o && o.seed && o.name === SEED_NAME && o.url !== url) continue;
+      kept.push(o);
+    }
+    if (kept.length !== list.length) saveConns(kept);
+    list = loadConns();
+    for (var i = 0; i < list.length; i++) {
+      var c = list[i];
+      if (!c) continue;
+      if (c.url === url && String(c.token || '') === String(TOKEN)) {
+        if (c.seed && c.name === SEED_LOCAL) { c.name = SEED_NAME; saveConns(list); }
+        return;
+      }
+      if (c.seed && c.url === url) {
+        c.token = TOKEN;
+        c.id = connIdOf({ url: url, token: TOKEN });
+        c.at = Date.now();
+        saveConns(list);
+        return;
+      }
+    }
+    seedMark(upsertConn({ url: url, token: TOKEN, name: SEED_NAME }));
+  }
+
+  /* ── 设备现场（按环境隔离）──
+     2026-10-22 用户：「切换环境后 所有东西都要跟着变 包括会话 需求 我的这些 是选择环境上的东西」。
+     会话与需求本来就来自桌面端（切完重拉）；这里解决的是**留在本机的那部分状态**：
+     主题 / 字体 / 任务模式 / 默认引擎与模型 / 团队配置 / 当前空间 / 置顶 / 通知 / 浏览器收藏。
+     做法：切环境时把这一组键快照到「按地址分桶」的槽里，再把目标环境的槽写回来，然后整页重载
+     —— 内存态全部重新初始化，不留上一台机器的影子。
+     ⚠️ 分桶键用 host:port 而不是 url|token：token 会随 App 重启变，按 token 分桶等于每次都丢现场。 */
+  var ENV_SCOPE_KEYS = [
+    'magic.ws', 'magic.taskmode', 'magic.engine', 'magic.model',
+    'magic.theme', 'magic.font', 'magic.haptic', 'magic.notify',
+    'magic.pinned', 'magic.spaces', 'magic.browser.stars.v1',
+    'magic.team.sessions.v1', 'magic.team.routes.v1', 'magic.team.rules.v1',
+    'magic.team.parallel', 'magic.team.split', 'magic.team.splitcode', 'magic.team.adaptive'
+  ];
+  var ENV_SCOPE_PREFIX = 'magic.envscope.v1.';
+  var ACTIVE_ENV_KEY = 'magic.remote.active.v1';   // 上次停在哪个环境（url）；重载后据此恢复
+  /* 正在切环境：此时全局键已经被 applyEnvScope 换成**目标环境**的值，
+     pagehide（reload 会触发）绝对不能再把这份值写回「旧环境」的槽 —— 那会把旧现场冲成空。 */
+  var ENV_SWITCHING = false;
+  function envScopeHash(s) {
+    var h = 5381, str = String(s || '');
+    for (var i = 0; i < str.length; i++) h = ((h << 5) + h + str.charCodeAt(i)) >>> 0;
+    return h.toString(36);
+  }
+  function envScopeIdOf(conn) {
+    var host = connHost((conn && conn.url) || connUrlNow());
+    return host ? envScopeHash(host) : '';
+  }
+  function envScopeId() { return envScopeIdOf(activeConn()); }
+  /* 把当前这组键存进 id 的槽（切走之前调用）。 */
+  function saveEnvScope(id) {
+    if (!id) return;
+    var o = {};
+    for (var i = 0; i < ENV_SCOPE_KEYS.length; i++) {
+      var v = null;
+      try { v = localStorage.getItem(ENV_SCOPE_KEYS[i]); } catch (e) {}
+      if (v !== null) o[ENV_SCOPE_KEYS[i]] = v;
+    }
+    try { localStorage.setItem(ENV_SCOPE_PREFIX + id, JSON.stringify(o)); } catch (e) {}
+  }
+  /* 把 id 的槽写回全局键；槽里没有的键删掉 —— 那台机器没改过的项回到默认，不继承上一台。 */
+  function applyEnvScope(id) {
+    var o = {};
+    if (id) {
+      try { o = JSON.parse(localStorage.getItem(ENV_SCOPE_PREFIX + id) || '{}') || {}; } catch (e) { o = {}; }
+    }
+    for (var i = 0; i < ENV_SCOPE_KEYS.length; i++) {
+      var k = ENV_SCOPE_KEYS[i];
+      try {
+        if (o[k] === undefined || o[k] === null) localStorage.removeItem(k);
+        else localStorage.setItem(k, o[k]);
+      } catch (e) {}
+    }
+  }
+
+  /* ── 环境配置的远端存储（2026-10-22 用户：「环境的配置应该在远程上 不是浏览器缓存
+     否则同一个环境多个客户端配置还不一致」）──
+     这台桌面怎么干活（默认引擎/模型、团队配置、空间选择、置顶）属于**环境**，
+     不属于某台手机：两个客户端连同一台桌面必须看到同一套配置。
+     所以这组键以 `/desk/prefs` 为准，localStorage 只当离线缓存：
+       · 连上后拉一次，远端是权威 → 有差异就覆盖本地并重载一次；
+       · 本地任何一处改了，防抖推回远端。
+     纯设备偏好（主题/字体/触感/通知）**不同步** —— 那是手机自己的事。 */
+  var PREF_SYNC_KEYS = [
+    'magic.engine', 'magic.model', 'magic.ws', 'magic.spaces', 'magic.pinned',
+    'magic.team.sessions.v1', 'magic.team.routes.v1', 'magic.team.rules.v1',
+    'magic.team.parallel', 'magic.team.split', 'magic.team.splitcode', 'magic.team.adaptive'
+  ];
+  var PREFS_PUSH_TIMER = 0, PREFS_PULLED = false, PREFS_PULLING = false;
+  function collectPrefs() {
+    var o = {};
+    for (var i = 0; i < PREF_SYNC_KEYS.length; i++) {
+      var v = null;
+      try { v = localStorage.getItem(PREF_SYNC_KEYS[i]); } catch (e) {}
+      if (v !== null) o[PREF_SYNC_KEYS[i]] = v;
+    }
+    return o;
+  }
+  function pushPrefs() {
+    if (!TOKEN) return;
+    try {
+      fetch(BASE + '/desk/prefs', {
+        method: 'PUT',
+        headers: { 'X-Magic-Token': TOKEN, 'Content-Type': 'application/json' },
+        body: JSON.stringify(collectPrefs())
+      }).catch(function () {});
+    } catch (e) {}
+  }
+  function schedulePushPrefs() {
+    if (!TOKEN) return;
+    if (PREFS_PUSH_TIMER) clearTimeout(PREFS_PUSH_TIMER);
+    PREFS_PUSH_TIMER = setTimeout(function () { PREFS_PUSH_TIMER = 0; pushPrefs(); }, 700);
+  }
+  /* 拉一次远端配置。远端是空对象 = 这台桌面还没存过 → 把本地这份推上去（迁移），
+     不反过来把本地清空 —— 老用户第一次升级时不能丢配置。 */
+  function pullPrefs() {
+    if (!TOKEN || PREFS_PULLING) return;
+    PREFS_PULLING = true;
+    var seq = CONN_SEQ;
+    fetch(BASE + '/desk/prefs', { headers: { 'X-Magic-Token': TOKEN } })
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .then(function (v) {
+        PREFS_PULLING = false;
+        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; }
+        var changed = false;
+        for (var i = 0; i < PREF_SYNC_KEYS.length; i++) {
+          var k = PREF_SYNC_KEYS[i];
+          var cur = null;
+          try { cur = localStorage.getItem(k); } catch (e) {}
+          var want = Object.prototype.hasOwnProperty.call(v, k) ? String(v[k]) : null;
+          if (want === cur) continue;
+          try {
+            if (want === null) localStorage.removeItem(k);
+            else localStorage.setItem(k, want);
+          } catch (e) {}
+          changed = true;
+        }
+        PREFS_PULLED = true;
+        if (changed) { try { location.reload(); } catch (e) {} }
+      })
+      .catch(function () { PREFS_PULLING = false; PREFS_PULLED = true; });
+  }
 
   /* 桌面 health 回来的应用名（app）补进当前连接：它比 host 更像「这台设备是谁」。 */
   function noteActiveMeta(meta) {
@@ -1524,23 +1814,24 @@ button.setrow{font-family:inherit}
   }
   /* 换环境 = 换一台桌面：对话、轮询、运行态都属于旧连接，必须一起收掉。
      排队任务按令牌分别落库（见 QUEUE_KEY），旧环境那批留在原地，切回来再接着跑。 */
+  /* 换环境 = 换一台桌面：会话 / 需求 / 我的设置全都属于那台机器。
+     做法分两步：① 把当前这台的本机状态快照进它的槽，再把目标环境的槽写回来；
+     ② 记住「停在哪个环境」并整页重载 —— 重载后内存态从零初始化，按目标环境的
+     连接与设置重建界面（会话、需求都是重载后从目标桌面现拉的）。
+     ⚠️ 不在这里手写「清哪些变量」：那种清单永远会漏（漏一个就带着上一台的数据）。 */
   function switchEnv(c) {
     if (!c) return;
-    if (c.url === BASE && String(c.token || '') === String(TOKEN || '')) {
+    if (c.url === connUrlNow() && String(c.token || '') === String(TOKEN || '')) {
       toast('已在「' + (connLabel(c) || '当前环境') + '」');
       return;
     }
-    if (conv) { try { conv.destroy(); } catch (e) {} conv = null; }
-    convEl.innerHTML = '';
-    stopPoll();
-    PENDING = []; ASK_WAITING = []; SERIAL = {}; QUEUE_RESTORED = false;
-    SERVER_VERSION = ''; CORE_FEATURES = []; TEAM_ROLES = []; ENGINES = []; ENGINES_STALE_AT = '';
-    TITLES = {}; LAST_SESSIONS = []; DW = ''; DW_READY = false; ROOT_DIRS = [];
-    /* 工作空间属于某台机器的目录树：沿用旧路径会落到不存在的目录，一律回到默认。 */
-    WS = '';
-    saveWs();
-    connect({ url: c.url, token: c.token, name: c.name, host: c.host || connHost(c.url) });
-    toast('已切换到「' + (connLabel(c) || connHost(c.url)) + '」');
+    ENV_SWITCHING = true;
+    saveEnvScope(envScopeId());                       // 旧环境的现场
+    applyEnvScope(envScopeIdOf(c));                   // 新环境的现场
+    var rec = upsertConn(c);                          // 保证这条在册（临时记录也能落盘）
+    try { localStorage.setItem(ACTIVE_ENV_KEY, rec.url || c.url || ''); } catch (e) {}
+    toast('正在切换到「' + (connLabel(c) || connHost(c.url)) + '」');
+    try { location.reload(); } catch (e) { location.href = location.href; }
   }
   function openEnvMenu() {
     if (envMenuEl) { closeEnvMenu(); return; }
@@ -1557,7 +1848,7 @@ button.setrow{font-family:inherit}
       var active = !!(cur && c.id === cur.id);
       var b = document.createElement('button');
       b.type = 'button';
-      b.className = 'envmenu__item';
+      b.className = 'envmenu__item' + (active ? ' is-active' : '');
       var ico = document.createElement('span');
       ico.className = 'envmenu__ico';
       ico.appendChild(svgUse('#i-laptop', 20));
@@ -1575,29 +1866,29 @@ button.setrow{font-family:inherit}
       var csub = (cname && cname !== chost) ? chost : '';
       col.appendChild(elSpan('envmenu__s', (csub ? csub + ' · ' : '') + (active ? '当前连接' : '点击切换')));
       b.appendChild(col);
-      if (active) {
-        var ck = document.createElement('span');
-        ck.className = 'envmenu__check';
-        ck.appendChild(svgUse('#i-check', 18));
-        b.appendChild(ck);
-      }
+      /* 每行一枚「修改」：改名 / 改链接不用绕去「我的」。行本身仍是切换。 */
+      var ed = document.createElement('span');
+      ed.className = 'envmenu__edit';
+      ed.setAttribute('role', 'button');
+      ed.setAttribute('aria-label', '编辑环境');
+      ed.appendChild(svgUse('#i-edit', 18));
+      ed.onclick = function (e) { e.stopPropagation(); closeEnvMenu(); openEnvEditor(c); };
+      b.appendChild(ed);
       b.onclick = function () { closeEnvMenu(); switchEnv(c); };
       envMenuEl.appendChild(b);
     });
     envMenuEl.appendChild(elSpan('envmenu__sep', ''));
-    /* 两个入口必须分开：新建环境 = 手填名字 + IP；扫码/粘贴 = 用配对页给的链接直接连。
-       以前只有后者，「环境没有地方配置 ip 和名字」（2026-10-22 用户）。 */
-    function menuAct(label, fn) {
+    /* 只留一个「添加环境」：扫码在启动页，改名改链接走每行的铅笔图标。 */
+    function menuAct(icon, label, fn) {
       var b = document.createElement('button');
       b.type = 'button';
       b.className = 'envmenu__add';
-      b.appendChild(svgUse('#i-plus', 18));
+      b.appendChild(svgUse(icon, 18));
       b.appendChild(elSpan('', label));
       b.onclick = function () { closeEnvMenu(); fn(); };
       envMenuEl.appendChild(b);
     }
-    menuAct('环境设置（名字 / IP）', function () { showEnvPage('tasks'); });
-    menuAct('扫码或粘贴连接地址', function () { showLauncher(); });
+    menuAct('#i-plus', '添加环境', function () { openEnvEditor(null); });
     document.body.appendChild(envScrimEl);
     document.body.appendChild(envMenuEl);
     var btn = document.getElementById('btnEnvSwitch');
@@ -1608,53 +1899,25 @@ button.setrow{font-family:inherit}
     btn.classList.add('is-open');
   }
 
-  /* ── 环境管理（我的 → 环境）：显式配置名字 / IP / 令牌 ──
-     2026-10-22 用户：「环境没有地方配置 ip 和名字啊」——
-     扫码只是「连上并记住」，不是配置入口。这里补上增删改。 */
-  function showEnvPage(from) {
-    hideAll(); envPageEl.hidden = false; tabbarEl.hidden = true;
-    ENV_BACK = from === 'tasks' ? 'tasks' : 'mine';
-    renderEnvPage();
-  }
-  var ENV_BACK = 'mine';   // 环境页的返回目标：从任务页标题进来就回任务页，从「我的」进来就回「我的」
-  function renderEnvPage() {
-    if (!envListEl) return;
-    envListEl.innerHTML = '';
-    var list = loadConns();
-    if (!list.length) {
-      envListEl.appendChild(hEl('div', 'history__hint', '还没有配置环境。点下面的「新建环境」，填名字和 IP 即可。'));
-      return;
-    }
-    var cur = activeConn();
-    list.forEach(function (c) {
-      var b = hEl('button', 'setrow');
-      b.type = 'button';
-      var main = hEl('span', 'setrow__main');
-      main.appendChild(hEl('span', 'setrow__l', connLabel(c) || '未命名'));
-      main.appendChild(hEl('span', 'setrow__sub',
-        (c.host || connHost(c.url)) + (cur && c.id === cur.id ? ' · 当前连接' : '')));
-      b.appendChild(main);
-      b.appendChild(hEl('span', 'setrow__v', '编辑'));
-      b.onclick = function () { openEnvEditor(c); };
-      envListEl.appendChild(b);
-    });
-  }
-  /* conn 为空 = 新建；否则编辑（名字、地址、令牌都能改，也能删）。 */
+  /* ── 环境编辑（任务页标题菜单里的铅笔 / 添加环境）：名字 / 链接 / 令牌 ──
+     2026-10-22 用户：「我的中的环境配置就不需要了」—— 管理入口只留在标题菜单里，
+     不再单独做一页。 */
+  /* conn 为空 = 新建；否则编辑（名字、链接、令牌都能改，也能删）。 */
   function openEnvEditor(conn) {
     var isNew = !conn;
-    openHostSheet(isNew ? '新建环境' : '编辑环境', function (body) {
+    openHostSheet(isNew ? '添加环境' : '编辑环境', function (body) {
       var nameEl = hEl('input', 'envfield');
       nameEl.type = 'text';
       nameEl.placeholder = '例如 公司 Mac';
       nameEl.value = (conn && conn.name) || '';
       var addrEl = hEl('input', 'envfield');
       addrEl.type = 'text';
-      addrEl.placeholder = '192.168.1.5:8791';
+      /* 「链接」= 桌面配对页给的那条地址，可整条粘进来（含 ?token=…）。 */
+      addrEl.placeholder = 'http://192.168.1.5:8791/?token=…';
       addrEl.setAttribute('autocapitalize', 'off');
       addrEl.setAttribute('autocomplete', 'off');
       addrEl.setAttribute('spellcheck', 'false');
-      /* 地址栏显示不带 http:// 的短形态（用户脑子里就是 IP:端口）；https 原样保留。 */
-      addrEl.value = conn && conn.url ? String(conn.url).replace(/^http:\/\//i, '') : '';
+      addrEl.value = (conn && conn.url) ? String(conn.url) : '';
       var tokEl = hEl('input', 'envfield');
       tokEl.type = 'text';
       tokEl.placeholder = '可选，配对令牌';
@@ -1664,15 +1927,26 @@ button.setrow{font-family:inherit}
       tokEl.value = (conn && conn.token) || '';
       body.appendChild(hEl('label', 'envlabel', '名称'));
       body.appendChild(nameEl);
-      body.appendChild(hEl('label', 'envlabel', '地址（IP:端口）'));
+      body.appendChild(hEl('label', 'envlabel', '链接'));
       body.appendChild(addrEl);
+      /* 扫码填入：启动页不再出现在主流程里之后，这里是唯一的扫码入口。 */
+      var scanB = hEl('button', 'envscan', '扫码填入');
+      scanB.type = 'button';
+      scanB.onclick = function () {
+        startScan(function (raw) {
+          addrEl.value = raw;
+          var t = parseTarget(raw);
+          if (t && t.token) tokEl.value = t.token;
+        }, function (m) { err.textContent = m; err.hidden = false; });
+      };
+      body.appendChild(scanB);
       body.appendChild(hEl('label', 'envlabel', '令牌'));
       body.appendChild(tokEl);
       var err = hEl('div', 'field__err');
       err.hidden = true;
       body.appendChild(err);
       body.appendChild(hEl('div', 'envhint',
-        '地址也可以带 ?token=…；下面这栏单独填时优先。填好保存后可在这里或任务页标题处切换。'));
+        '链接从桌面配对页复制，可以带 ?token=…；令牌栏单独填时优先。'));
       var acts = hEl('div', 'envacts');
       var saveB = hEl('button', 'btn btn--filled', '保存');
       var goB = hEl('button', 'btn btn--outlined', '保存并连接');
@@ -1690,7 +1964,7 @@ button.setrow{font-family:inherit}
         err.hidden = true;
         var raw = String(addrEl.value || '').trim();
         var t = parseTarget(raw);
-        if (!t) { err.textContent = '请填地址，例如 192.168.1.5:8791'; err.hidden = false; return null; }
+        if (!t) { err.textContent = '请填链接，例如 http://192.168.1.5:8791/?token=…'; err.hidden = false; return null; }
         var tok = String(tokEl.value || '').trim();
         var hadParam = /[?&]token=/.test(raw);
         if (tok) t.token = tok;
@@ -1702,7 +1976,7 @@ button.setrow{font-family:inherit}
         return t;
       }
       function persist(t) {
-        var wasActive = !!(conn && conn.url === BASE && String(conn.token || '') === String(TOKEN || ''));
+        var wasActive = !!(conn && conn.url === connUrlNow() && String(conn.token || '') === String(TOKEN || ''));
         var next = upsertConn(t);
         /* 改了地址/令牌 = 换了一条记录：旧的那条要删掉，别留一条连不上的僵尸。 */
         if (conn && conn.id !== next.id) removeConn(conn.id);
@@ -1719,9 +1993,7 @@ button.setrow{font-family:inherit}
           switchEnv(next);   // 改的正是当前这台：按新地址/令牌重连
           return;
         }
-        renderEnvPage();
         if (!historyEl.hidden) historyTitle.textContent = envLabel() || '任务';
-        if (!mineEl.hidden && mineEnv) mineEnv.textContent = envLabel() || '—';
         toast(isNew ? ('已添加「' + (next.name || next.host) + '」') : '已保存');
       }
       saveB.onclick = function () { var t = collect(); if (t) persist(t); };
@@ -1731,14 +2003,13 @@ button.setrow{font-family:inherit}
         persist(t);
         /* persist 内部遇到「改的是当前连接」已经自己重连了；这里只处理新增/改别的环境。 */
         var c = findConn(connIdOf(t)) || findConn(connIdOf({ url: t.url, token: t.token }));
-        if (c && !(c.url === BASE && String(c.token || '') === String(TOKEN || ''))) switchEnv(c);
+        if (c && !(c.url === connUrlNow() && String(c.token || '') === String(TOKEN || ''))) switchEnv(c);
       };
       if (delB) {
         delB.onclick = function () {
           if (!window.confirm('删除环境「' + (connLabel(conn) || conn.host || '') + '」？')) return;
           removeConn(conn.id);
           closeHostSheet();
-          renderEnvPage();
           toast('已删除');
         };
       }
@@ -1773,7 +2044,7 @@ button.setrow{font-family:inherit}
   }
 
   /* ══════════ 视图：启动页 → 会话列表 → 会话 ══════════ */
-  function hideAll() { launcherEl.hidden = true; historyEl.hidden = true; mineEl.hidden = true; reqsEl.hidden = true; discoverEl.hidden = true; teamPageEl.hidden = true; runSettingsPageEl.hidden = true; pluginsEl.hidden = true; pluginDetailEl.hidden = true; sessionEl.hidden = true; envPageEl.hidden = true; }
+  function hideAll() { launcherEl.hidden = true; historyEl.hidden = true; mineEl.hidden = true; reqsEl.hidden = true; reqDetailEl.hidden = true; discoverEl.hidden = true; teamPageEl.hidden = true; runSettingsPageEl.hidden = true; pluginsEl.hidden = true; pluginDetailEl.hidden = true; sessionEl.hidden = true; }
   function setActive(name) {
     Array.prototype.forEach.call(tabbarEl.querySelectorAll('.tab'), function (b) {
       b.classList.toggle('is-on', b.getAttribute('data-tab') === name);
@@ -1789,6 +2060,14 @@ button.setrow{font-family:inherit}
     hideAll(); historyEl.hidden = false; tabbarEl.hidden = false; setActive('tasks');
     if (address != null) histSubtitle = address;
     historyTitle.textContent = envLabel() || '任务';
+    /* 一条环境都没有（首次安装 / 刚断开）：直接进任务页的空态。
+       2026-10-22 用户：「这个界面不需要了 直接切换环境就行」—— 不再用独立的启动页挡在前面。 */
+    if (!TOKEN && !BASE) {
+      historyTitle.textContent = '未连接';
+      historyList.innerHTML = '<div class="history__hint" style="text-align:left">还没有连接桌面端。'
+        + '点上面的标题 →「添加环境」，把桌面给的地址粘进来（也可以在里面扫码）。</div>';
+      return;
+    }
     loadSessions();
   }
   function showSession(sub) { hideAll(); sessionEl.hidden = false; tabbarEl.hidden = false; setActive('tasks'); subtitleEl.textContent = (sub != null ? sub : histSubtitle) || ''; }
@@ -1797,13 +2076,14 @@ button.setrow{font-family:inherit}
      两者代价差三个数量级，绝不能混成一个动作。 */
   function showReqs() {
     hideAll(); reqsEl.hidden = false; tabbarEl.hidden = false; setActive('reqs');
+    /* 从二级退回来时不要还卡在详情态：回到底栏「需求」这一页 = 回到一级目录。 */
+    REQ_DETAIL = null;
     loadRequirements(false);
   }
   function showDiscover() { hideAll(); discoverEl.hidden = false; tabbarEl.hidden = false; setActive('discover'); }
   function showMine() {
     hideAll(); mineEl.hidden = false; tabbarEl.hidden = false; setActive('mine');
     mineDevice.textContent = histSubtitle || '本机';
-    if (mineEnv) mineEnv.textContent = envLabel() || '—';
     var ns = document.getElementById('notifyState');
     if (ns) { var p = notifyPermState(); ns.textContent = p === 'plugin' ? '已接入' : (p === 'granted' ? '已开启' : '未开启'); }
     markSeg(segTheme, PREFS.theme); markSeg(segFont, PREFS.font); markSeg(segMode, TASK_MODE);
@@ -1814,39 +2094,114 @@ button.setrow{font-family:inherit}
        再补一次请求 —— 用户可能一连上就直接点「我的」，那时列表那次还没回来。 */
     paintMineVersion();
     refreshMineVersion();
+    /* 顺带问一次「桌面端的包里带的是哪一版 APK」：有更新就把这一格显示成「升级 vX」。 */
+    probeAppUpdate();
   }
 
-  /* ══════════ 版本号（「我的」）══════════
-     来源：桌面端 `GET /desk/health` 的 `version`（= core 的 `--version`，ldflags 注入）。
-     为什么不是移动端自己写死一个常量：这份界面是桌面端 `/m/` 远程加载的，页面文件跟着
-     桌面端一起升级；只有服务端报的版本才是「用户此刻连着的这份」。
-     health 没有 version（插件是旧构建、但磁盘上的 core 已经是新的）时，再问一次
-     `/desk/contract` —— 它原样代理 core 的 envelope，新 core 里带 version。这样
-     **不必重启正在跑的服务**就能显示真实版本。仍然没有（老 core）就保持「—」，不编。 */
+  /* ══════════ 版本号 + 升级（「我的」）══════════
+     显示：优先 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）→ 提示检查失败，不把「—」当成最新版本。 */
   var SERVER_VERSION = '';
+  var APK_LATEST = '';   // 桌面端 npm 包里带的 APK 版本（/desk/app）；空 = 没包或还没查
+  function shownVersion() { return APP_VERSION || SERVER_VERSION; }
   function paintMineVersion() {
     if (!mineVersion) return;
-    mineVersion.textContent = SERVER_VERSION ? ('v' + SERVER_VERSION) : '—';
+    var v = shownVersion();
+    var txt = v ? ('v' + v) : '—';
+    /* 有新版本就直接在这一格写「升级」，别让用户去猜这一行能不能点。 */
+    if (v && APK_LATEST && cmpVersion(APK_LATEST, v) > 0) {
+      mineVersion.textContent = txt + ' · 升级 v' + APK_LATEST;
+      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) : '';
+  }
+  /* 进入「我的」时静默问一次桌面端带的是哪一版 APK：有更新就把版本格变成「升级」。
+     失败（老插件没有 /desk/app）就不动，不打扰。 */
+  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 () {});
   }
   function refreshMineVersion() {
     if (!TOKEN) { paintMineVersion(); return; }
     var hdr = { 'X-Magic-Token': TOKEN };
-    var seq = CONN_SEQ;   // 切环境后旧桌面的 health 不许写到新连接上
-    fetch(BASE + '/desk/health', { headers: hdr })
+    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 })
       .then(function (r) { return r.ok ? r.json() : null; })
-      .then(function (h) {
-        if (seq !== CONN_SEQ) return;
-        if (h && h.app) noteActiveMeta({ app: h.app });
-        if (h && typeof h.version === 'string' && h.version) { SERVER_VERSION = h.version; return; }
-        return fetch(BASE + '/desk/contract', { headers: hdr })
-          .then(function (r) { return r.ok ? r.json() : null; })
-          .then(function (c) {
-            if (c && typeof c.version === 'string' && c.version) SERVER_VERSION = c.version;
-          })
-          .catch(function () {});
+      .catch(function () { return null; });
+    var pHealth = fetch(BASE + '/desk/health', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : null; })
+      .catch(function () { return null; });
+    Promise.all([pContract, pHealth]).then(function (a) {
+      if (seq !== CONN_SEQ) return;
+      var c = a[0], h = a[1];
+      if (h && h.app) noteActiveMeta({ app: h.app });
+      if (c && typeof c.version === 'string' && c.version) SERVER_VERSION = c.version;
+      else if (h && typeof h.version === 'string' && h.version) SERVER_VERSION = h.version;
+      paintMineVersion();
+    });
+  }
+  function cmpVersion(a, b) {
+    var pa = String(a || '0').split('.'), pb = String(b || '0').split('.');
+    for (var i = 0; i < 3; i++) {
+      var x = parseInt(pa[i], 10) || 0, y = parseInt(pb[i], 10) || 0;
+      if (x !== y) return x - y;
+    }
+    return 0;
+  }
+  /* 下载走系统能力：APK 壳里 MainActivity 挂了 MagicUpdate.open（Intent.ACTION_VIEW），
+     浏览器预览退化为直接导航到下载地址（浏览器会下载，不会把页面留在 APK 上）。 */
+  function openApkDownload(info) {
+    var rel = (info && info.url) || '/desk/app.apk';
+    var url;
+    if (/^https?:/i.test(rel)) {
+      url = rel;
+    } else if (BASE) {
+      url = BASE + rel;
+    } else {
+      /* 远程界面与 /desk/ 同源，BASE 是空串；交给原生 Intent 的必须是绝对地址。 */
+      try { url = new URL(rel, location.href).toString(); } catch (e) { url = rel; }
+    }
+    url += (url.indexOf('?') >= 0 ? '&' : '?') + 'token=' + encodeURIComponent(TOKEN);
+    try {
+      if (window.MagicUpdate && typeof window.MagicUpdate.open === 'function') {
+        window.MagicUpdate.open(url);
+        return;
+      }
+    } catch (e) {}
+    location.href = url;
+  }
+  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;
+        openApkDownload(a);
+        toast('正在下载 v' + a.version + '，完成后点安装');
       })
-      .then(paintMineVersion)
-      .catch(function () { paintMineVersion(); });   // 网络抖动：保留旧值，不把「—」又闪回来
+      .catch(function () { paintMineVersion(); toast('检查更新失败，请确认桌面端已升级'); });
   }
   /* 「我的」→ 团队模式：整块配置进子页面（与插件列表同一套子页面范式）。 */
   function showTeamPage() {
@@ -2408,6 +2763,9 @@ button.setrow{font-family:inherit}
     CONN_SEQ++;              // 上一台桌面还在飞的请求：回来时直接丢弃（见 loadSessions）
     var c = upsertConn(target);
     ACTIVE_ID = c.id;
+    PREFS_PULLED = false;   // 换了桌面：环境配置要重新从新桌面拉一次（见 pullPrefs）
+    /* 记住「停在哪台」：下次打开（或切环境后重载）直接回到这里。 */
+    try { localStorage.setItem(ACTIVE_ENV_KEY, c.url || target.url || ''); } catch (e) {}
     showError('');
     showHistory(c.host || '');
     startPoll();
@@ -2419,8 +2777,10 @@ button.setrow{font-family:inherit}
     CONN_SEQ++;
     if (conv) { try { conv.destroy(); } catch (e) {} conv = null; }
     convEl.innerHTML = '';
+    saveEnvScope(envScopeId());   // 断开前把这台的本机状态留在它自己的槽里
     BASE = ''; TOKEN = '';
     ACTIVE_ID = '';
+    try { localStorage.removeItem(ACTIVE_ENV_KEY); } catch (e) {}   // 主动断开 = 下次回启动页
     SERVER_VERSION = '';   // 版本号属于「那一条连接」：断开就清掉，避免下次连到别的机器还显示旧值
     /* 排队任务**不跟着断连消失**（它们已经落库）：只清内存里的等待态，下次连上由
        restoreQueue 从磁盘接回来。串行门的 FIFO 也一并重置 —— 里面的 tail 是挂在一条
@@ -2429,7 +2789,8 @@ button.setrow{font-family:inherit}
     ASK_WAITING = [];
     SERIAL = {};
     QUEUE_RESTORED = false;
-    showLauncher();
+    /* 断开后回任务页的空态（不再回启动页）：添加/切换环境都在标题菜单里。 */
+    showHistory(null);
   }
 
   /* ══════════ 历史会话列表（GET /desk/sessions，字段同 core 的 --sessions）══════════ */
@@ -2499,16 +2860,26 @@ button.setrow{font-family:inherit}
       TITLES = a[1] || {};
       DW = (a[2] && a[2].defaultWorkspace) || '';
       DW_READY = true;
+      /* 环境配置以桌面端为准：连上后拉一次（见 pullPrefs）。只拉一次，
+         后面本地的改动由 schedulePushPrefs 推回去。 */
+      if (!PREFS_PULLED) pullPrefs();
       SPACES_ROOT = (a[2] && a[2].workspacesRoot) || '';
-      /* core 版本（2026-10-22）：/desk/health 的 version，顺手缓存，「我的」页打开即用。
-         老 core 没有该字段 → 不覆盖已有值（可能刚由 refreshMineVersion 拿到）。 */
-      if (a[2] && a[2].version) SERVER_VERSION = a[2].version;
+      /* core 版本不要从这里取：/desk/health.version 是插件启动时的缓存，可能是旧值
+         （见 refreshMineVersion 的注释）。版本行打开时走 /desk/contract 拿实时值。 */
       if (!mineEl.hidden) paintMineVersion();
       /* core 能力位（feature.*）：团队开关要不要显示就看它。连上桌面后才有，
          所以「我的」那张卡片与运行设置里的那一行都要在这里刷一次。 */
       CORE_FEATURES = ((a[2] && a[2].features) || []);
       /* 连接的身份（app）：连着哪台设备就记到哪条连接上，环境菜单里当类型标签用。 */
       if (a[2] && a[2].app) noteActiveMeta({ app: a[2].app });
+      /* 桌面绑了公网隧道时上报 publicUrl（cloudflared，不在同一 Wi-Fi 也能连），
+         没有则退回局域网入口：自动补一条「公司远程」环境，用户不用手抄地址。 */
+      if (a[2]) {
+        var remotes = [];
+        if (a[2].publicUrl) remotes.push(a[2].publicUrl);
+        if (a[2].lanUrls && a[2].lanUrls.length) remotes = remotes.concat(a[2].lanUrls);
+        if (remotes.length) seedRemoteConns(remotes);
+      }
       /* 团队角色清单（2026-10-22）：core 上报什么就画什么，客户端不硬编码角色名。
          老 core 没有 teamRoles → 空数组 → paintTeamPref 用内置表兜底。 */
       TEAM_ROLES = ((a[2] && a[2].teamRoles) || []).filter(function (r) {
@@ -2546,7 +2917,7 @@ button.setrow{font-family:inherit}
   var TASK_QUERY = '';
   var PINNED = [];
   try { PINNED = JSON.parse(localStorage.getItem('magic.pinned') || '[]') || []; } catch (e) { PINNED = []; }
-  function savePinned() { try { localStorage.setItem('magic.pinned', JSON.stringify(PINNED)); } catch (e) {} }
+  function savePinned() { try { localStorage.setItem('magic.pinned', JSON.stringify(PINNED)); } catch (e) {} schedulePushPrefs(); }
   var TITLES = {};   // 服务端标题覆盖表（GET /desk/titles），重命名用
   var DW = '';       // 桌面默认工作空间（GET /desk/health 的 defaultWorkspace = core 的 cwd）
   var DW_READY = false;   // DW 是否已从 health 落定（空间键归一依赖它，见 restoreQueue）
@@ -2554,7 +2925,7 @@ button.setrow{font-family:inherit}
   var ROOT_DIRS = [];     // 根目录下 magic-* 目录（GET /desk/dirs）
   var CUSTOM_SPACES = [];
   try { CUSTOM_SPACES = JSON.parse(localStorage.getItem('magic.spaces') || '[]') || []; } catch (e) { CUSTOM_SPACES = []; }
-  function saveSpaces() { try { localStorage.setItem('magic.spaces', JSON.stringify(CUSTOM_SPACES)); } catch (e) {} }
+  function saveSpaces() { try { localStorage.setItem('magic.spaces', JSON.stringify(CUSTOM_SPACES)); } catch (e) {} schedulePushPrefs(); }
   /* 空间候选 = 根目录下的 magic-* + 自定义 + 会话里出现过的 workspace（去重、保序）。
      ⚠️ 会话的 workspace 为空时**不要**拿 DW 顶上（原写法 `s.workspace || DW`）：
         那样「默认（不指定）」与「默认目录名」会变成两行同名选项，一个落「任务」段、
@@ -2568,6 +2939,44 @@ button.setrow{font-family:inherit}
     (LAST_SESSIONS || []).forEach(function (s) { add(s && s.workspace); });
     return out;
   }
+  /* 会话里哪些是**顶层会话**（不是别人的子会话）。
+     团队模式会把子代理的会话挂到父会话下面去，它们的工作目录是
+     /…/run-xxx/a1 这种**临时目录** —— 任务页不把它们单独列成空间
+     （见 renderSessions 的 CHILD_OF 归类），需求页若照单全收就会多出
+     一堆 a1/t1/tmp 之类的假空间（用户 2026-10-22：「没有空间的不需要」）。
+     口径必须与任务页一致，所以这里按同一套父子关系判。 */
+  function topLevelSessions(list) {
+    var rows = list || [];
+    var key2sid = {};
+    rows.forEach(function (s) {
+      var sid = sidOf(s);
+      if (!sid) return;
+      key2sid[sid] = sid;
+      if (s.run_id) key2sid[s.run_id] = sid;
+      if (s.session_id) key2sid[s.session_id] = sid;
+    });
+    return rows.filter(function (s) {
+      var pk = key2sid[parentKeyOf(s)] || '';
+      return !(pk && pk !== sidOf(s));
+    });
+  }
+  /* 一个目录算不算「空间」：得是**用户认得的工作区**。
+     根目录 / 不是空间（哪怕历史上有会话在那儿跑过）—— 需求页显示它只会让人
+     以为「/ 是个项目」（用户 2026-10-22：「没有空间的不需要」）。
+     ⚠️ 别把整个 /tmp 一刀切：/tmp/teamapi 是用户自己建的项目，是真空间
+     （任务页也列着它）。团队运行目录另有专门的判法（见 isTeamRunDir）。 */
+  function isRealSpaceDir(dir) {
+    var d = reqNormDir(dir);
+    if (!d) return false;          // 根目录 /（归一后是空串）
+    if (isTeamRunDir(d)) return false;
+    return true;
+  }
+  /* 团队模式的运行目录：<空间>/.magic/team/run-xxx[/子代理目录]。
+     这些是团队**这一轮**的工作区，跑完就没了 —— 不是用户意义上的空间。 */
+  function isTeamRunDir(dir) {
+    var d = reqNormDir(dir);
+    return d.indexOf('/.magic/team/') >= 0;
+  }
   /* 会话标题：**以 core 给的 title 为准**（2026-10-15，用户「应该 magic-agent 统一归纳作为
      会话标题」）。core 的 --sessions 已把「标题表覆盖 → prompt_head」合并成一个 title 字段，
      所以这里不再自己拼优先级 —— 此前本文件是 `TITLES[id] || prompt_head`、PC 端是另一套
@@ -3209,6 +3618,10 @@ button.setrow{font-family:inherit}
   var REQ_BUSY = false;        // 「整理」进行中（防重复点击）
   var REQ_BUSY_LABEL = '全部整理'; // 顶栏按钮的进行中文案（重渲染后要能恢复）
   var REQ_OPEN = {};           // 工作区展开状态（key = 工作区 id），与会话列表的 WS_OPEN 同构
+  var REQ_ALIVE = null;        // 仍有会话的空间路径集合；null = 拿不到会话清单（不筛）
+  var REQ_DETAIL = null;       // 二级视图：{key: 工作区 key, mod: 模块名, ws: 工作区对象}
+  /* 路径归一：只去尾部斜杠，不做 realpath —— 与 core 登记表里的 workspace 同一口径。 */
+  function reqNormDir(p) { return String(p || '').replace(/\/+$/, ''); }
 
   function reqFeatureRow(f) {
     /* 一行 = 一个功能点，**照会话行的排布**做（图标 + 标题 / 副标题 / 右侧时间）：
@@ -3243,17 +3656,27 @@ button.setrow{font-family:inherit}
     return b;
   }
 
-  /* 工作区组：与会话列表的 workspaceGroup 同一套骨架（可折叠的组头 + 组内行）。
-     差别只有两点：组头右侧没有「+ 新建」，行是需求文档不是会话。 */
-  function reqWorkspaceBlock(w) {
+  /* 一级：空间目录。空间是行，模块缩进挂在空间下（树形），**功能点一律不画在这里**。
+     一级只回答「这个空间有哪几块、每块多少条」—— 需求一多时画功能点会把目录撑成长列表，
+     结构反而看不见了（2026-10-22 用户定稿：两级，一级只显示空间和模块）。
+     idx = 排序后的位次（0 = 需求条数最多的那个）。 */
+  function reqWorkspaceBlock(w, idx) {
     var wrap = hEl('div', '');
     var head = hEl('div', 'wsrow__head');
     var key = w.id || w.dir || w.name || '';
     var count = Number(w.feature_count) || 0;
-    var open = (REQ_OPEN[key] !== undefined) ? !!REQ_OPEN[key] : true;   // 需求页默认全展开
+    /* 默认只展开**第一个**（需求条数最多的那个），其余折叠（用户 2026-10-22）：
+       空间一多，全展开就是一屏拉到底的长列表，什么结构都看不出来。
+       用户手动点过谁就按用户的来（REQ_OPEN 里有记录就不动它）。 */
+    var open = (REQ_OPEN[key] !== undefined) ? !!REQ_OPEN[key] : (idx === 0);
     var tog = document.createElement('button');
-    tog.type = 'button'; tog.className = 'wsrow__open';
+    tog.type = 'button'; tog.className = 'wsrow__open wsrow__open--req';
     tog.appendChild(elSpan('wsrow__l', w.name || w.dir || w.id));
+    /* 模块数 + 功能点数：一行说清这个空间有多大，比只写空间名有用。
+       用**中性色**（不是 wsrow__badge 那枚 queued 紫）—— 那是「等待中」的语义色，
+       空间规模不是状态，套上会让人误以为这个空间在排队。 */
+    var mods = (w.modules || []).filter(function (m) { return (m.features || []).length; });
+    tog.appendChild(elSpan('wsrow__meta', mods.length + ' 模块 · ' + count + ' 条'));
     /* 待整理条数做成徽标（与「等待中」同款）：折叠起来也看得见这个空间在长新需求。 */
     if (w.pending > 0) tog.appendChild(elSpan('wsrow__badge', w.pending + ' 待整理'));
     /* 未初始化 = 还没按空间目录生成过基线。老 core 不带 initialized 字段（undefined），
@@ -3281,55 +3704,141 @@ button.setrow{font-family:inherit}
       err.style.color = 'var(--warning)';
       wrap.appendChild(err);
     }
+    var shown = 0;
     (w.modules || []).forEach(function (m) {
-      /* 模块（大功能点）用一条小节标题，形状与「置顶 / 任务 / 空间」的 sechead 一致：
-         名字 + 条数。未归类（name 为空）不标题、直接平铺 ——
-         老数据是平铺目录，硬给它编个「未归类」反而像出了错。 */
       var fs = (m.features || []);
       if (!fs.length) return;
-      if (m.name) {
-        var mh = hEl('div', 'sechead');
-        mh.style.paddingLeft = '16px';
-        mh.appendChild(elSpan('sechead__t', m.name + ' (' + fs.length + ')'));
-        wrap.appendChild(mh);
-      }
-      fs.forEach(function (f) { wrap.appendChild(reqFeatureRow(f)); });
+      shown += fs.length;
+      /* 模块 = 目录里的一行（缩进 + 连接线归属到空间），点它进二级看需求列表。
+         未归类（name 为空）的老数据没有模块名可写 —— 这种情况直接不画这一行，
+         功能点仍能在二级里看到（core 把空 module 排在最后）。 */
+      if (!m.name) return;
+      var row = document.createElement('button');
+      row.type = 'button'; row.className = 'reqtree__mod';
+      row.appendChild(elSpan('reqtree__modname', m.name));
+      row.appendChild(elSpan('reqtree__modcount', String(fs.length)));
+      var go = elSpan('reqtree__modgo');
+      go.appendChild(svgUse('#i-chev-r', 16));
+      row.appendChild(go);
+      row.onclick = function () { openReqDetail(w, m.name); };
+      wrap.appendChild(row);
     });
+    /* 空间还在但还没有文档：别画成一片空白，给出这一组的下一步（整理）。 */
+    if (!shown) {
+      var tip = Number(w.pending) > 0
+        ? '有 ' + w.pending + ' 条对话待整理'
+        : (w.initialized === false ? '还没有需求文档，点右侧「整理」按空间生成' : '还没有需求文档');
+      var hint = hEl('div', 'history__hint', tip);
+      hint.style.padding = '6px 12px 12px';
+      wrap.appendChild(hint);
+    }
     return wrap;
   }
 
+  /* 二级：某空间下**所有模块**的需求列表（用户 2026-10-22 定稿）。
+     进来的那个模块高亮，滚到它那儿；其余模块照常列出来 —— 需求之间有交叉，
+     只看当前模块会漏掉相关需求。 */
+  function reqDetailBlock(d) {
+    var w = d.ws;
+    var frag = document.createDocumentFragment();
+    (w.modules || []).forEach(function (m) {
+      var fs = (m.features || []);
+      if (!fs.length) return;
+      var sec = hEl('div', 'reqdetail__sec' + (m.name === d.mod ? ' reqdetail__sec--cur' : ''));
+      var mh = hEl('div', 'sechead');
+      mh.style.paddingLeft = '16px';
+      mh.appendChild(elSpan('sechead__t', (m.name || '未归类') + ' (' + fs.length + ')'));
+      sec.appendChild(mh);
+      fs.forEach(function (f) { sec.appendChild(reqFeatureRow(f)); });
+      frag.appendChild(sec);
+    });
+    if (!frag.childNodes.length) {
+      frag.appendChild(hEl('div', 'history__hint', '这个空间还没有需求文档'));
+    }
+    return frag;
+  }
+
+  /* 进二级：记下是哪个空间的哪个模块，渲染后滚到那个模块。 */
+  function openReqDetail(w, mod) {
+    var key = w.id || w.dir || w.name || '';
+    REQ_DETAIL = { key: key, mod: mod, ws: w };
+    renderRequirements();
+    /* 空间在两次渲染之间被删掉了（会话全删 → 空间联动消失）：
+       renderRequirements 会把 REQ_DETAIL 清空，这时别停在空白的二级页，退回目录。 */
+    if (!REQ_DETAIL) { hideAll(); reqsEl.hidden = false; tabbarEl.hidden = false; return; }
+    hideAll(); reqDetailEl.hidden = false; tabbarEl.hidden = true;
+    if (reqDetailTitle) reqDetailTitle.textContent = (w.name || w.dir || w.id) + ' · ' + mod;
+    /* 滚到当前模块：它高亮，但用户进来第一眼要看到的是自己点的那一块。 */
+    if (reqDetailListEl) {
+      var cur = reqDetailListEl.querySelector('.reqdetail__sec--cur');
+      if (cur && cur.scrollIntoView) cur.scrollIntoView({ block: 'start' });
+    }
+  }
+
+  /* 退二级回一级目录。 */
+  function closeReqDetail() {
+    REQ_DETAIL = null;
+    hideAll(); reqsEl.hidden = false; tabbarEl.hidden = false;
+    renderRequirements();
+  }
+
   function renderRequirements() {
     if (!reqListEl) return;
     var data = REQ_DATA;
     if (!data) return;
-    /* 只画**有文档**的工作区（用户 2026-10-22：「没有的空间不显示」）。
-       feature_count 是 core 给的真值；老 core 不给时退化成数一遍模块里的行数。 */
+    /* 空间清单与任务页对齐：**用与 collectSpaceKeys 同一套空间键过滤**
+       （用户 2026-10-22：「4个空间需求里显示的不一样」「会话中全部删除后需求中的空间还在
+       也要联动删除」）。没有文档的空间不再整块藏掉，而是留一个组头 + 「整理」按钮 ——
+       这样两页的空间数一致，也给了「这个空间还没生成需求」的入口。
+       拿不到会话/目录清单时（REQ_ALIVE=null）不筛。 */
     var all = (data && data.workspaces) || [];
     var list = all.filter(function (w) {
-      if (Number(w.feature_count) > 0) return true;
-      return (w.modules || []).some(function (m) { return (m.features || []).length > 0; });
+      var dir = reqNormDir(w && w.dir);
+      /* 根目录 / 归一后是空串 —— 「!dir 就放行」的老写法会把它漏进来，
+         需求页于是出现一个叫「/」的假空间（用户 2026-10-22：「没有空间的不需要」）。
+         这里先卡一道：不是真空间目录的直接不画。 */
+      if (!isRealSpaceDir(dir)) return false;
+      return !REQ_ALIVE || !dir || !!REQ_ALIVE[dir];
+    });
+    /* 排序：**需求条数多的排前面**（用户 2026-10-22）。
+       core 给的顺序是「最后归纳时间倒序」，但那是给「最近在动的」用的；
+       需求页要回答的是「哪块需求最多」，条数多的才是用户要先看的那个。
+       条数一样时按名字排 —— 同一条数下顺序要稳定，不能每次刷新都在跳。 */
+    list.sort(function (a, b) {
+      var ca = Number(a && a.feature_count) || 0;
+      var cb = Number(b && b.feature_count) || 0;
+      if (ca !== cb) return cb - ca;
+      return String((a && a.name) || '').localeCompare(String((b && b.name) || ''));
     });
+    /* 二级视图：只画这个空间的需求列表。空间可能已被会话删除联动掉
+       （list 里没有它）—— 那就退回一级目录，不要留一页空白。 */
+    if (REQ_DETAIL) {
+      var hit = null;
+      for (var i = 0; i < list.length; i++) {
+        if ((list[i].id || list[i].dir || list[i].name || '') === REQ_DETAIL.key) { hit = list[i]; break; }
+      }
+      if (!hit) { REQ_DETAIL = null; }
+      else {
+        REQ_DETAIL.ws = hit;
+        if (reqDetailTitle) reqDetailTitle.textContent = (hit.name || hit.dir || hit.id) + ' · ' + REQ_DETAIL.mod;
+        if (reqDetailListEl) reqDetailListEl.replaceChildren(reqDetailBlock(REQ_DETAIL));
+        if (REQ_BUSY) reqSetBusy(true, REQ_BUSY_LABEL);
+        return;
+      }
+    }
     var frag = document.createDocumentFragment();
     if (!list.length) {
-      /* 一个功能点都还没有：说清「是没聊过」还是「聊过但没整理」——
-         后者要引导用户点「整理」，否则这一页看起来永远长不出东西。 */
-      var pend = 0, uninit = 0;
-      all.forEach(function (w) {
-        pend += Number(w.pending) || 0;
-        if (w.initialized === false) uninit++;
-      });
+      /* 一个空间都没有（会话全删了 / 还没聊过）。 */
       frag.appendChild(hEl('div', 'history__hint',
-        pend > 0
-          ? '有 ' + pend + ' 条对话还没整理成需求。点空间右侧「整理」只处理这个空间；右上角「全部整理」一次跑完所有空间。'
-          : (uninit > 0
-            ? '还没有需求。点空间右侧「整理」会先按空间目录生成一版需求基线；右上角「全部整理」一次处理所有空间。'
-            : '还没有任何需求。在任务里聊几句，这里会自动整理出功能点文档。')));
+        REQ_ALIVE
+          ? '还没有任何空间。在任务里聊几句，这里会按空间整理出功能点文档。'
+          : '还没有任何需求。在任务里聊几句，这里会自动整理出功能点文档。'));
       reqListEl.replaceChildren(frag);
       return;
     }
-    /* 工作区顺序照 core 给的（最后归纳时间倒序）—— 最近在动的排最前，
-       用户打开这一页多半是想看「刚聊的那些变成什么了」。 */
-    list.forEach(function (w) { frag.appendChild(reqWorkspaceBlock(w)); });
+    /* 工作区顺序：上面已按需求条数排好（多的在前）。默认只展开第一个 ——
+       见 reqWorkspaceBlock 的 open 判定。 */
+    list.forEach(function (w, i) { frag.appendChild(reqWorkspaceBlock(w, i)); });
     reqListEl.replaceChildren(frag);
     /* 整理进行中切走再回来：新 DOM 的按钮默认是可点的，这里按当前状态重新置忙。 */
     if (REQ_BUSY) reqSetBusy(true, REQ_BUSY_LABEL);
@@ -3339,7 +3848,7 @@ button.setrow{font-family:inherit}
     if (!reqListEl) return;
     if (!quiet && !REQ_DATA) reqListEl.innerHTML = '<div class="history__hint">读取中…</div>';
     var hdr = TOKEN ? { 'X-Magic-Token': TOKEN } : {};
-    fetch(BASE + '/desk/requirements', { headers: hdr })
+    var pReq = fetch(BASE + '/desk/requirements', { headers: hdr })
       .then(function (r) {
         if (r.status === 501) {
           /* 老 core 没有这个能力位：**说清楚**，不要给一页空白
@@ -3348,9 +3857,38 @@ button.setrow{font-family:inherit}
         }
         if (!r.ok) throw new Error('HTTP ' + r.status);
         return r.json();
-      })
-      .then(function (d) {
-        REQ_DATA = d || { workspaces: [] };
+      });
+    /* 会话清单与空间目录：用来判断「这个空间在任务页还在不在」。
+       两者都允许失败 —— 拿不到就不筛空间（见 renderRequirements）。 */
+    var pSess = fetch(BASE + '/desk/sessions', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
+    var pDirs = fetch(BASE + '/desk/dirs', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
+    Promise.all([pReq, pSess, pDirs])
+      .then(function (a) {
+        var sess = a[1], dirs = (a[2] && a[2].dirs) || null;
+        if (Array.isArray(sess) || Array.isArray(dirs)) {
+          /* 与任务页**同一套空间键**（用户 2026-10-22：「4个空间需求里显示的不一样」
+             「会话中全部删除后需求中的空间还在 也要联动删除」「没有空间的不需要」）：
+               ① 根目录下的 magic-*   ② 自定义空间   ③ **顶层会话**的工作目录。
+             ⚠️ ③ 只能取**顶层**会话的 workspace：团队子代理的会话挂在父会话下面，
+             它们的工作目录是 /…/run-xxx/a1 这种临时目录 —— 任务页不把它们列成空间，
+             需求页照收就会多出一堆 a1/t1/tmp 假空间。
+             ⚠️ 根目录 / 与 /tmp 这类系统目录不是空间，哪怕历史上有会话在那儿跑过。 */
+          var alive = {};
+          (ROOT_DIRS || []).forEach(function (d) { if (d && d.path) alive[reqNormDir(d.path)] = 1; });
+          (dirs || []).forEach(function (d) {
+            if (d && d.path && String(d.name || '').indexOf('magic-') === 0) alive[reqNormDir(d.path)] = 1;
+          });
+          (CUSTOM_SPACES || []).forEach(function (p) { if (p) alive[reqNormDir(p)] = 1; });
+          topLevelSessions(sess).forEach(function (s) {
+            if (s && s.workspace && isRealSpaceDir(s.workspace)) alive[reqNormDir(s.workspace)] = 1;
+          });
+          REQ_ALIVE = alive;
+        } else {
+          REQ_ALIVE = null;   // 清单没拿到：不筛，宁可多显示
+        }
+        REQ_DATA = a[0] || { workspaces: [] };
         renderRequirements();
       })
       .catch(function (e) {
@@ -3389,7 +3927,8 @@ button.setrow{font-family:inherit}
   }
 
   /* 统一置忙：顶部主按钮 + 所有空间组头的「整理」一起禁用。
-     label 只改顶部；组头统一显示「整理中…」/「整理」，不各自变文案。 */
+     label 只改顶部；组头统一显示「整理中…」/「整理」，不各自变文案。
+     二级页那枚「整理」也跟着禁用 —— 归纳期间它和组头一样不能重复点。 */
   function reqSetBusy(on, label) {
     if (on) { if (label !== undefined) REQ_BUSY_LABEL = label; }
     else REQ_BUSY_LABEL = '全部整理';
@@ -3398,6 +3937,11 @@ button.setrow{font-family:inherit}
       btn.disabled = !!on;
       if (label !== undefined) btn.textContent = label;
     }
+    var dbtn = document.getElementById('btnReqDetailSync');
+    if (dbtn) {
+      dbtn.disabled = !!on;
+      dbtn.textContent = on ? '整理中…' : '整理';
+    }
     Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
       b.disabled = !!on;
       b.textContent = on ? '整理中…' : '整理';
@@ -3444,6 +3988,9 @@ button.setrow{font-family:inherit}
     var list = ((REQ_DATA && REQ_DATA.workspaces) || []).filter(function (w) {
       var key = w.dir || w.id || '';
       if (!key || seen[key]) return false;
+      /* 会话已全部删除的空间不参与「全部整理」：否则又会把它重新生成出来。 */
+      var dir = reqNormDir(w.dir);
+      if (REQ_ALIVE && dir && !REQ_ALIVE[dir]) return false;
       seen[key] = true;
       return true;
     });
@@ -3496,6 +4043,13 @@ button.setrow{font-family:inherit}
     step();
   }
   on('btnReqSync', function () { consolidateAllRequirements(); });
+  /* 二级视图的两个动作：返回一级目录 / 整理**当前这个空间**（不是全部空间 ——
+     二级页的作用域就是这个空间，标成「全部整理」会让人以为还是全局动作）。 */
+  on('btnReqDetailBack', function () { closeReqDetail(); });
+  on('btnReqDetailSync', function () {
+    if (!REQ_DETAIL || !REQ_DETAIL.ws) return;
+    consolidateRequirements(REQ_DETAIL.ws);
+  });
 
   function openHostSheet(title, build) {
     closeHostSheet();
@@ -4225,6 +4779,7 @@ button.setrow{font-family:inherit}
       localStorage.setItem('magic.engine', RUN_PREF.engine || '');
       localStorage.setItem('magic.model', RUN_PREF.model || '');
     } catch (e) {}
+    schedulePushPrefs();
     paintRunPref();
   }
   function paintRunPref() {
@@ -4257,14 +4812,13 @@ button.setrow{font-family:inherit}
     var sum = document.getElementById('teamSummary');
     if (sum) sum.textContent = custom ? (custom + ' 项已单独指定') : '跟随主引擎';
   }
-  /* 团队模式子页面 = **两张卡**（用户 2026-10-22：「配引擎和配规则要分开配置 不要在 1 个页面」）：
-     #teamRouteCard「交给谁」= 计划 + 7 个角色的引擎/模型，点开只有引擎；
-     #teamRuleCard「规则」= 计划的拆解口径 + 7 个角色的「适合什么」，点开只有规则。
+  /* 团队模式子页面 = **一张卡、每行两个触发点**（用户 2026-10-22：「两个触发就行了」）：
+     左边（名字 + 规则描述）→ 只改规则；右边（引擎值）→ 只选引擎。
+     两块配置分属两个抽屉，但不必各占一整张卡。
      签名含两侧文案与引擎：变了才重建，避免 5s 轮询时闪。 */
   function paintTeamRoles(roles) {
-    var routeCard = document.getElementById('teamRouteCard');
-    var ruleCard = document.getElementById('teamRuleCard');
-    if (!routeCard || !ruleCard) return;
+    var card = document.getElementById('teamRouteCard');
+    if (!card) return;
     var show = teamSupported();
     var plan = (TEAM.routes || {}).plan || {};
     var planSub = '拆解：' + ({ coarse: '少', standard: '标准', fine: '细' }[TEAM.split] || '标准')
@@ -4277,50 +4831,36 @@ button.setrow{font-family:inherit}
       }).join(',');
     if (sig === TEAM_ROLE_SIG) return;
     TEAM_ROLE_SIG = sig;
-    routeCard.innerHTML = '';
-    ruleCard.innerHTML = '';
+    card.innerHTML = '';
     if (!show) return;
-    /* 上卡：只讲「交给谁」，右侧是引擎；不展示规则描述。 */
-    addTeamRouteRow(routeCard, 'plan', '计划任务');
+    addTeamSplitRow(card, 'plan', '计划任务', planSub);
     roles.forEach(function (r) {
-      addTeamRouteRow(routeCard, 'role:' + r.name, TEAM_ROLE_LABELS[r.name] || r.name);
-    });
-    /* 下卡：只讲「规则」——计划是拆解口径，角色是「这类适合什么」。 */
-    addTeamRuleRow(ruleCard, 'plan', '计划任务规则', planSub);
-    roles.forEach(function (r) {
-      var label = (TEAM_ROLE_LABELS[r.name] || r.name) + '规则';
-      addTeamRuleRow(ruleCard, 'role:' + r.name, label, teamRoleDuty(r));
+      addTeamSplitRow(card, 'role:' + r.name, TEAM_ROLE_LABELS[r.name] || r.name, teamRoleDuty(r));
     });
   }
-  /* 上卡的一行：名字 + 右侧引擎。点开 = 只选引擎/模型。 */
-  function addTeamRouteRow(card, key, label) {
+  /* 一行两个点击区：左边改规则，右边选引擎。
+     ⚠️ 外层必须是 div —— button 不能套 button；`.setrow` 的边框/间距照常用在外层。 */
+  function addTeamSplitRow(card, key, label, sub) {
     var rt = (TEAM.routes || {})[key] || {};
-    var b = hEl('button', 'setrow');
-    b.type = 'button';
-    var main = hEl('span', 'setrow__main');
+    var row = hEl('div', 'setrow setrow--split');
+    var main = hEl('button', 'setrow__mainbtn');
+    main.type = 'button';
     main.appendChild(hEl('span', 'setrow__l', label));
-    b.appendChild(main);
-    b.appendChild(hEl('span', 'setrow__v',
+    if (sub) main.appendChild(hEl('span', 'setrow__sub', sub));
+    main.onclick = function () { openTeamRuleSheet(key, label + '：规则'); };
+    row.appendChild(main);
+    var v = hEl('button', 'setrow__vbtn');
+    v.type = 'button';
+    v.appendChild(hEl('span', 'setrow__v',
       rt.engine ? (rt.engine + (rt.model ? ' · ' + qaModelText(rt.model) : '')) : '跟随主引擎'));
-    b.appendChild(hEl('span', 'setrow__chev', '›'));
-    b.onclick = function () {
+    v.appendChild(hEl('span', 'setrow__chev', '›'));
+    v.onclick = function () {
       openTeamEnginePicker(key,
         String(key).indexOf('role:') === 0 ? (label + '交给谁') : '计划任务交给谁',
         teamRoleKindOf(key));
     };
-    card.appendChild(b);
-  }
-  /* 下卡的一行：名字 + 当前规则。点开 = 只改规则（不含引擎）。 */
-  function addTeamRuleRow(card, key, label, sub) {
-    var b = hEl('button', 'setrow');
-    b.type = 'button';
-    var main = hEl('span', 'setrow__main');
-    main.appendChild(hEl('span', 'setrow__l', label));
-    if (sub) main.appendChild(hEl('span', 'setrow__sub', sub));
-    b.appendChild(main);
-    b.appendChild(hEl('span', 'setrow__chev', '›'));
-    b.onclick = function () { openTeamRuleSheet(key, label); };
-    card.appendChild(b);
+    row.appendChild(v);
+    card.appendChild(row);
   }
   function teamRoleKindOf(key) {
     if (String(key).indexOf('role:') !== 0) return 'plan';
@@ -4747,6 +5287,9 @@ button.setrow{font-family:inherit}
   document.getElementById('btnConnect').onclick = function () {
     var target = parseTarget(addrEl.value);
     if (!target) { showError('请输入 magic-agent 桌面地址（形如 http://192.168.1.5:8791/?token=…）'); return; }
+    /* 名称栏（2026-10-22）：手填的优先于地址里的 ?name=，连上后就是环境名。 */
+    var nm = connNameEl ? String(connNameEl.value || '').trim() : '';
+    if (nm) target.name = nm;
     connect(target);
   };
   addrEl.addEventListener('input', function () { showError(''); });
@@ -4792,10 +5335,6 @@ button.setrow{font-family:inherit}
      归属只在用户显式选空间时确定，不能让上一次的 WS 悄悄粘过来。 */
   on('btnFabNew', function () { newConversation(); });
   on('btnMineBack', function () { showHistory(); });
-  /* 我的 → 环境（多连接）：列表（点行编辑）+ 新建；返回回「我的」。 */
-  on('btnEnvPage', function () { showEnvPage('mine'); });
-  on('btnEnvBack', function () { if (ENV_BACK === 'tasks') showHistory(); else showMine(); });
-  on('btnEnvAdd', function () { openEnvEditor(null); });
   on('dscBrowser', function () { openBrowser(HOME_URL); });
   on('dscApps', function () { openComingSheet('应用', '暂无可用应用。桌面端发布的应用会出现在这里。'); });
   on('dscPlugins', function () { showPlugins(); });
@@ -4819,6 +5358,7 @@ button.setrow{font-family:inherit}
   on('btnTeamBack', showMine);
   on('btnLogout', disconnect);
   on('btnUpgrade', reloadApp);
+  on('btnMineVersion', checkAppUpdate);
   if (segTheme) takeSeg(segTheme, 'magic.theme', function (v) { PREFS.theme = v; applyThemePref(v); });
   if (segFont) takeSeg(segFont, 'magic.font', function (v) { PREFS.font = v; applyFontPref(v); });
   if (segMode) takeSeg(segMode, 'magic.taskmode', function (v) { TASK_MODE = v; });
@@ -4880,12 +5420,13 @@ button.setrow{font-family:inherit}
     scanEl.hidden = true;
   }
   document.getElementById('btnScanClose').onclick = stopScan;
-  document.getElementById('btnScan').onclick = function () {
+  /* 通用扫码：扫到就把原文交给回调（启动页用来直连，「添加环境」用来填链接）。 */
+  function startScan(onResult, onError) {
+    var fail = onError || function (m) { toast(m); };
     if (!('BarcodeDetector' in window) || !navigator.mediaDevices) {
-      showError('当前环境不支持扫码，请把桌面配对页的「桌面地址」粘贴到输入框。');
+      fail('当前环境不支持扫码，请把桌面给的地址粘贴进来。');
       return;
     }
-    showError('');
     scanEl.hidden = false;
     navigator.mediaDevices.getUserMedia({ video: { facingMode: 'environment' } }).then(function (stream) {
       scanStream = stream;
@@ -4898,19 +5439,47 @@ button.setrow{font-family:inherit}
         scanDetector.detect(scanVideo).then(function (codes) {
           if (!codes || !codes.length) return;
           stopScan();
-          var raw = codes[0].rawValue || '';
-          var target = parseTarget(raw);
-          if (target) connect(target);
-          else showError('这个二维码不是 magic-agent 连接地址。');
+          onResult(codes[0].rawValue || '');
         }).catch(function () {});
       }, 400);
     }).catch(function () {
       stopScan();
-      showError('无法启动相机，请改用粘贴地址的方式。');
+      fail('无法启动相机，请改用粘贴地址的方式。');
     });
+  }
+  document.getElementById('btnScan').onclick = function () {
+    showError('');
+    startScan(function (raw) {
+      var target = parseTarget(raw);
+      if (!target) { showError('这个二维码不是 magic-agent 连接地址。'); return; }
+      var nm = connNameEl ? String(connNameEl.value || '').trim() : '';
+      if (nm) target.name = nm;
+      connect(target);
+    }, function (m) { showError(m); });
   };
 
   window.addEventListener('pagehide', stopScan);
+  /* 关掉 App / 刷新之前也把这台的本机状态记进它自己的槽：
+     用户改完设置不一定马上切环境，不记就会在下次启动时丢。 */
+  window.addEventListener('pagehide', function () {
+    if (!TOKEN || ENV_SWITCHING) return;
+    try { saveEnvScope(envScopeId()); } catch (e) {}
+  });
+
+  /* 壳注入的那条连接换令牌了（App 每次启动都会换）：把存档里同地址的记录同步过去。
+     否则「切回本机」会用一枚已经失效的旧令牌去连，表现成「这台连不上」。 */
+  function syncInjectedConnToken(url, tok) {
+    if (!url || !tok) return;
+    var list = loadConns(), changed = false;
+    for (var i = 0; i < list.length; i++) {
+      var c = list[i];
+      if (!c || c.url !== url || String(c.token || '') === String(tok)) continue;
+      c.token = tok;
+      c.id = connIdOf({ url: url, token: tok });
+      changed = true;
+    }
+    if (changed) saveConns(list);
+  }
 
   /* ══════════ 首屏 ══════════
      · 打包进 App（Capacitor）：boot.js 注入 window.MAGIC_BASE / MAGIC_TOKEN → 直连会话；
@@ -4919,16 +5488,56 @@ button.setrow{font-family:inherit}
   var injectedToken = window.MAGIC_TOKEN || new URLSearchParams(location.search).get('token') || '';
   var injectedBase = (window.MAGIC_BASE || '').replace(/\/+$/, '');
   try {
-    if (injectedToken || injectedBase) {
+    /* 上次停在哪个环境（见 switchEnv）：切过环境后整页重载，必须回到**那台**，
+       否则壳注入的地址会把人拽回本机 —— 用户会看到「切了又跳回来」。 */
+    var injUrl = injectedBase || (injectedToken ? location.origin : '');
+    syncInjectedConnToken(injUrl, injectedToken);
+    var resumed = false;
+    try {
+      var lastUrl = localStorage.getItem(ACTIVE_ENV_KEY) || '';
+      if (lastUrl) {
+        var saved = loadConns();
+        for (var i = 0; i < saved.length; i++) {
+          var sc = saved[i];
+          if (!sc || sc.url !== lastUrl) continue;
+          /* 同一地址（壳注入的这台）令牌以注入为准：App 每次启动会换令牌，存档里的旧令牌已失效。 */
+          var tok = (lastUrl === injUrl && injectedToken)
+            ? injectedToken : (sc.token || injectedToken);
+          if (!tok) break;
+          BASE = sc.url; TOKEN = tok; ACTIVE_ID = sc.id;
+          showHistory(sc.host || connHost(sc.url));
+          restoreQueue();
+          resumed = true;
+          break;
+        }
+      }
+    } catch (e) { resumed = false; }
+    if (!resumed && (injectedToken || injectedBase)) {
       BASE = injectedBase; TOKEN = injectedToken;
+      /* 把当前这条（壳注入的）连接落成环境，名字默认「公司远程」——
+         否则它只是一条改不了名、也留不住的「未命名」。 */
+      seedCurrentConn();
       showHistory(injectedBase ? injectedBase.replace(/^https?:\/\//, '') : '本机');
       restoreQueue();      // App 重启：上次没轮到的排队任务接着排（见 restoreQueue）
-    } else {
-      showLauncher();
+    } else if (!resumed) {
+      /* 没有注入、也没有可恢复的上次环境：有存过的环境就直接连最近用过的那条；
+         一条都没有才进任务页空态 —— 不再用独立启动页挡在前面
+         （2026-10-22 用户：「这个界面不需要了 直接切换环境就行」）。 */
+      var all = loadConns().filter(function (c) { return c && c.url; });
+      all.sort(function (a, b) { return (b.at || 0) - (a.at || 0); });
+      var pick = all[0];
+      if (pick) {
+        BASE = pick.url; TOKEN = pick.token || ''; ACTIVE_ID = pick.id;
+        try { localStorage.setItem(ACTIVE_ENV_KEY, pick.url); } catch (e) {}
+        showHistory(pick.host || connHost(pick.url));
+        restoreQueue();
+      } else {
+        showHistory(null);
+      }
     }
   } catch (e) {
-    /* 任何初始化异常都退回启动页，绝不留白屏。 */
-    try { showLauncher(); } catch (e2) {}
+    /* 任何初始化异常都退回任务页空态，绝不留白屏。 */
+    try { showHistory(null); } catch (e2) { try { showLauncher(); } catch (e3) {} }
   }
 
   /* ══════════ 启动闪屏：掌天瓶灌绿液（2026-10-20 用户：「app 启动动画也要有绿液」）══════════