magic-agent 2.3.2 → 2.3.9

package/client-ui-mobile/index.html

@@ -1575,24 +1575,44 @@ button.setrow{font-family:inherit}
     var id = connIdOf(t);
     var old = findConn(id) || {};
     var list = loadConns().filter(function (c) { return c.id !== id; });
+    /* eid：环境的稳定身份（见 ensureEnvId）。改地址/改令牌时由调用方带过来（t.eid），
+       否则沿用老记录的；都没有才发新号。 */
+    var eid = t.eid || old.eid || newEid();
     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(),
+      eid: eid,
       seed: !!old.seed      // 种出来的默认环境：改名/改地址后仍然认出它
     };
     list.unshift(next);
     saveConns(list);
+    /* 第一次拿到 eid：把这个环境原先按 host 哈希分区的队列行与配置槽迁过来。 */
+    if (!old.eid && !t.eid) migrateEnvData(envHashOf(next), eidKey(eid));
     return next;
   }
-  function removeConn(id) {
+  /* 删环境时把它名下的排队任务一起清掉：地址可能被别的服务器复用，
+     留着就会在下次连上时被当成那台的任务发出去。
+     keepQueue=true 用于「改地址/改令牌」——那不是删环境，eid 不变，队列要跟着走。 */
+  function removeConn(id, keepQueue) {
     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) {} }
+    if (hit && !keepQueue) dropEnvQueue(hit);
     saveConns(list.filter(function (c) { return c.id !== id; }));
   }
+  /* 清掉某条环境名下的排队行（eid 桶与老 host 桶都清）。 */
+  function dropEnvQueue(conn) {
+    if (!conn) return;
+    var keys = [eidKey(conn.eid), envHashOf(conn)].filter(function (k) { return !!k; });
+    if (!keys.length) return;
+    try {
+      var rows = readQueueAll().filter(function (p) { return !p || keys.indexOf(String(p.env || '')) < 0; });
+      localStorage.setItem(QUEUE_KEY, JSON.stringify(rows));
+    } catch (e) {}
+  }
   function clearConns() {
     saveConns([]);
     try {
@@ -1688,9 +1708,12 @@ button.setrow{font-family:inherit}
     /* 隧道换域名（cloudflared 每次重启都换）：把上一枚**默认命名**的种子远程记录换到新地址。
        用户改过名字的不动 —— 那条是他自己配的环境。 */
     var kept = [];
+    var replacedEid = '';
     for (var k = 0; k < list.length; k++) {
       var o = list[k];
-      if (o && o.seed && o.name === SEED_NAME && o.url !== url) continue;
+      /* 隧道换域名 = 同一台桌面换了入口：把它的 eid 带过去，
+         否则新记录会发新号，这台环境排队中的任务与配置槽全部变孤儿。 */
+      if (o && o.seed && o.name === SEED_NAME && o.url !== url) { replacedEid = o.eid || replacedEid; continue; }
       kept.push(o);
     }
     if (kept.length !== list.length) saveConns(kept);
@@ -1710,16 +1733,17 @@ button.setrow{font-family:inherit}
         return;
       }
     }
-    seedMark(upsertConn({ url: url, token: TOKEN, name: SEED_NAME }));
+    seedMark(upsertConn({ url: url, token: TOKEN, name: SEED_NAME, eid: replacedEid }));
   }
 
   /* ── 设备现场（按环境隔离）──
      2026-10-22 用户：「切换环境后 所有东西都要跟着变 包括会话 需求 我的这些 是选择环境上的东西」。
      会话与需求本来就来自桌面端（切完重拉）；这里解决的是**留在本机的那部分状态**：
      主题 / 字体 / 任务模式 / 默认引擎与模型 / 团队配置 / 当前空间 / 置顶 / 通知 / 浏览器收藏。
-     做法：切环境时把这一组键快照到「按地址分桶」的槽里，再把目标环境的槽写回来，然后整页重载
+     做法：切环境时把这一组键快照到「按环境身份分桶」的槽里，再把目标环境的槽写回来，然后整页重载
      —— 内存态全部重新初始化，不留上一台机器的影子。
-     ⚠️ 分桶键用 host:port 而不是 url|token：token 会随 App 重启变，按 token 分桶等于每次都丢现场。 */
+     ⚠️ 分桶键用稳定 eid（见 ensureEnvId），不是 url|token（令牌会轮换）、也不是 host:port
+        （换 IP/端口/隧道域名就变成另一台，现场全丢）。老数据按 host 哈希做一次迁移。 */
   var ENV_SCOPE_KEYS = [
     'magic.ws', 'magic.taskmode', 'magic.hosting.sessions.v1', 'magic.engine', 'magic.model',
     'magic.suggest.engine', 'magic.suggest.model',
@@ -1738,11 +1762,64 @@ button.setrow{font-family:inherit}
     for (var i = 0; i < str.length; i++) h = ((h << 5) + h + str.charCodeAt(i)) >>> 0;
     return h.toString(36);
   }
-  function envScopeIdOf(conn) {
+  /* ── 稳定环境身份（eid）──
+     地址会变（IP/端口/隧道域名），令牌会轮换（App 每次启动换注入令牌），两者都不能当环境身份：
+     地址变了 → 旧队列/旧配置变孤儿；地址被别的服务器复用 → 旧队列发错环境。
+     eid 在环境第一次落盘时生成，之后跟着这条记录走：改地址、改令牌都不换号。 */
+  function newEid() {
+    return 'e' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+  }
+  function eidKey(id) { return id ? ('eid:' + id) : ''; }
+  /* 老版本按 host:port 分区的键（只用于一次性迁移和「还没拿到 eid」的临时记录）。 */
+  function envHashOf(conn) {
     var host = connHost((conn && conn.url) || connUrlNow());
     return host ? envScopeHash(host) : '';
   }
+  function envScopeIdOf(conn) {
+    if (conn && conn.eid) return eidKey(conn.eid);
+    return envHashOf(conn);
+  }
   function envScopeId() { return envScopeIdOf(activeConn()); }
+  /* 给一条**已落盘**的环境补 eid（老记录没有），并把按 host 分区的旧队列/旧配置槽迁过来。 */
+  function ensureEnvId(conn) {
+    if (!conn) return conn;
+    var oldHash = envHashOf(conn);
+    if (conn.eid) {
+      migrateEnvData(oldHash, eidKey(conn.eid));   // 上次可能只写了一半：重入也要幂等补齐
+      return conn;
+    }
+    var list = loadConns(), hit = null;
+    /* 扫码/粘贴进来的临时目标没有 id：按 url+令牌现算一个，才能跟上已落盘的那条。 */
+    var wantId = conn.id || connIdOf({
+      url: conn.url || connUrlNow(),
+      token: conn.token != null ? conn.token : (TOKEN || '')
+    });
+    for (var i = 0; i < list.length; i++) if (list[i] && list[i].id === wantId) { hit = list[i]; break; }
+    if (!hit) return conn;          // 临时记录（还没落盘）：等 upsertConn 落盘时再发号
+    hit.eid = newEid();
+    saveConns(list);
+    migrateEnvData(oldHash, eidKey(hit.eid));
+    return hit;
+  }
+  /* 把旧键名下的排队行与配置槽搬到新键名下（幂等）。 */
+  function migrateEnvData(from, to) {
+    if (!from || !to || from === to) return;
+    migrateQueueEnv(from, to);
+    try {
+      var v = localStorage.getItem(ENV_SCOPE_PREFIX + from);
+      if (v != null) {
+        if (localStorage.getItem(ENV_SCOPE_PREFIX + to) == null) localStorage.setItem(ENV_SCOPE_PREFIX + to, v);
+        localStorage.removeItem(ENV_SCOPE_PREFIX + from);
+      }
+    } catch (e) {}
+  }
+  function migrateQueueEnv(from, to) {
+    try {
+      var rows = readQueueAll(), changed = false;
+      rows.forEach(function (p) { if (p && String(p.env || '') === from) { p.env = to; changed = true; } });
+      if (changed) localStorage.setItem(QUEUE_KEY, JSON.stringify(rows));
+    } catch (e) {}
+  }
   /* 把当前这组键存进 id 的槽（切走之前调用）。 */
   function saveEnvScope(id) {
     if (!id) return;
@@ -1893,7 +1970,8 @@ button.setrow{font-family:inherit}
     if (btn) btn.classList.remove('is-open');
   }
   /* 换环境 = 换一台桌面：对话、轮询、运行态都属于旧连接，必须一起收掉。
-     排队任务按令牌分别落库（见 QUEUE_KEY），旧环境那批留在原地，切回来再接着跑。 */
+     排队任务按**环境**分别落库（见 QUEUE_KEY）：旧环境那批留在原地，切回来再接着跑 ——
+     队列绝不能被带到另一台环境上跑，那边的会话结束事件这边根本收不到。 */
   /* 换环境 = 换一台桌面：会话 / 需求 / 我的设置全都属于那台机器。
      做法分两步：① 把当前这台的本机状态快照进它的槽，再把目标环境的槽写回来；
      ② 记住「停在哪个环境」并整页重载 —— 重载后内存态从零初始化，按目标环境的
@@ -1901,6 +1979,7 @@ button.setrow{font-family:inherit}
      ⚠️ 不在这里手写「清哪些变量」：那种清单永远会漏（漏一个就带着上一台的数据）。 */
   function switchEnv(c) {
     if (!c) return;
+    c = ensureEnvId(c) || c;          // 先把目标环境的 eid 补上，下面取槽才是稳定键
     if (c.url === connUrlNow() && String(c.token || '') === String(TOKEN || '')) {
       toast('已在「' + (connLabel(c) || '当前环境') + '」');
       return;
@@ -2057,9 +2136,12 @@ button.setrow{font-family:inherit}
       }
       function persist(t) {
         var wasActive = !!(conn && conn.url === connUrlNow() && String(conn.token || '') === String(TOKEN || ''));
+        /* 改地址/改令牌 = 同一台环境换了入口：eid 带过去，队列与配置槽跟着走。 */
+        if (conn && conn.eid) t.eid = conn.eid;
         var next = upsertConn(t);
-        /* 改了地址/令牌 = 换了一条记录：旧的那条要删掉，别留一条连不上的僵尸。 */
-        if (conn && conn.id !== next.id) removeConn(conn.id);
+        /* 改了地址/令牌 = 换了一条记录：旧的那条要删掉，别留一条连不上的僵尸。
+           队列已经跟着 eid 走了，这里不能再按旧记录清一遍。 */
+        if (conn && conn.id !== next.id) removeConn(conn.id, true);
         /* 名称允许清空，也允许改：upsertConn 会沿用旧名，这里按输入框的最终值覆盖。 */
         var list = loadConns();
         for (var i = 0; i < list.length; i++) {
@@ -2886,12 +2968,12 @@ button.setrow{font-family:inherit}
     TEAM.fresh = false;
     HOSTING.fresh = false;
     try {
-      var transport = window.MagicTransportHttp({ base: BASE, token: TOKEN, client: 'mobile' });
+      var transport = wrapTransportForJobs(window.MagicTransportHttp({ base: BASE, token: TOKEN, client: 'mobile' }));
       conv = window.MagicConversation.create({
         el: convEl, transport: transport, titleEl: titleEl, workspace: WS,
         engine: RUN_PREF.engine, model: RUN_PREF.model,
         /* 建议功能默认关闭：只有「我的 → 建议引擎」里显式选了引擎才传非空值；
-           模型为空 = 引擎默认（core 对 llm 会自动挑最快变体）。 */
+           模型为空 = 引擎默认（建议生成对 llm 用 no-think 变体作默认值）。 */
         suggestEngine: SUGGEST.engine, suggestModel: SUGGEST.model,
         showPermission: false, showAttach: true, beforeAsk: gateAsk,
         onInterrupt: cancelWaitingAsk,
@@ -3012,6 +3094,15 @@ button.setrow{font-family:inherit}
   }
 
   function connect(target) {
+    if (!target) return;
+    /* 已经连着另一台：换环境必须走 switchEnv（整页重载）。
+       就地改 BASE/TOKEN 会把内存里的队列、串行门、会话组件留在旧环境，
+       而 saveQueue 又会把旧 PENDING 行按新环境重标后发出去 —— 这正是跨环境串队的入口。 */
+    if ((BASE || TOKEN) && (String(target.url || '') !== String(connUrlNow()) ||
+        String(target.token || '') !== String(TOKEN || ''))) {
+      switchEnv(target);
+      return;
+    }
     BASE = target.url || '';
     TOKEN = target.token || '';
     CONN_SEQ++;              // 上一台桌面还在飞的请求：回来时直接丢弃（见 loadSessions）
@@ -3036,6 +3127,7 @@ button.setrow{font-family:inherit}
     ACTIVE_ID = '';
     try { localStorage.removeItem(ACTIVE_ENV_KEY); } catch (e) {}   // 主动断开 = 下次回启动页
     SERVER_VERSION = '';   // 版本号属于「那一条连接」：断开就清掉，避免下次连到别的机器还显示旧值
+    SERVER_JOBS = false;   // 作业队列能力也属于那一条连接
     /* 排队任务**不跟着断连消失**（它们已经落库）：只清内存里的等待态，下次连上由
        restoreQueue 从磁盘接回来。串行门的 FIFO 也一并重置 —— 里面的 tail 是挂在一条
        已废弃页面上的 promise，留着会让新连接的第一条永远排在它后面。 */
@@ -3114,6 +3206,7 @@ button.setrow{font-family:inherit}
       TITLES = a[1] || {};
       DW = (a[2] && a[2].defaultWorkspace) || '';
       DW_READY = true;
+      SERVER_JOBS = !!(a[2] && a[2].jobs);
       /* 环境配置以桌面端为准：连上后拉一次（见 pullPrefs）。只拉一次，
          后面本地的改动由 schedulePushPrefs 推回去。 */
       if (!PREFS_PULLED) pullPrefs();
@@ -3177,6 +3270,10 @@ button.setrow{font-family:inherit}
   var TITLES = {};   // 服务端标题覆盖表（GET /desk/titles），重命名用
   var DW = '';       // 桌面默认工作空间（GET /desk/health 的 defaultWorkspace = core 的 cwd）
   var DW_READY = false;   // DW 是否已从 health 落定（空间键归一依赖它，见 restoreQueue）
+  /* 服务端作业队列是否可用（GET /desk/health 的 jobs 字段，2026-10-23）。
+     有它：排队与互斥在服务端（多客户端同一 workspace 串行 + request_id 幂等）；
+     没有：退回本地串行门（老服务端，只有本设备自己排）。 */
+  var SERVER_JOBS = false;
   var SPACES_ROOT = '';   // 工作空间根（health.workspacesRoot）
   var ROOT_DIRS = [];     // 根目录下 magic-* 目录（GET /desk/dirs）
   var CUSTOM_SPACES = [];
@@ -3361,18 +3458,19 @@ button.setrow{font-family:inherit}
     rowMenuEl.style.top = Math.max(12, Math.min(r.top, window.innerHeight - mh - 12)) + 'px';
     rowMenuEl.style.left = Math.max(12, Math.min(r.left + 10, window.innerWidth - mw - 12)) + 'px';
   }
-  /* 重命名：写服务端标题表（PUT /desk/session/{id}/title），成功后就地更新并重绘。 */
+  /* 重命名：写服务端标题表（PUT /desk/session/{id}/title），成功后就地更新并重绘。
+     输入走抽屉里的真输入框（openTextInputSheet）—— window.prompt 在悬浮球 / WebView 里
+     点了没反应，与「自定义路径」是同一处坑（2026-10-23）。 */
   function renameSession(s) {
     var id = sidOf(s);
-    var name = window.prompt('重命名会话', titleOf(s));
-    if (name == null) return;
-    name = name.trim(); if (!name) return;
-    var hdr = { 'Content-Type': 'application/json' };
-    if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
-    fetch(BASE + '/desk/session/' + encodeURIComponent(id) + '/title', { method: 'PUT', headers: hdr, body: JSON.stringify({ title: name }) })
-      .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
-      .then(function () { TITLES[id] = name; renderSessions(LAST_SESSIONS); })
-      .catch(function (e) { window.alert('重命名失败：' + (e && e.message ? e.message : e)); });
+    openTextInputSheet({ title: '重命名会话', value: titleOf(s), emptyHint: '名称不能为空' }, function (name) {
+      var hdr = { 'Content-Type': 'application/json' };
+      if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
+      fetch(BASE + '/desk/session/' + encodeURIComponent(id) + '/title', { method: 'PUT', headers: hdr, body: JSON.stringify({ title: name }) })
+        .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
+        .then(function () { TITLES[id] = name; renderSessions(LAST_SESSIONS); })
+        .catch(function (e) { toast('重命名失败：' + (e && e.message ? e.message : e)); });
+    });
   }
   /* 删除一棵会话树：删主会话时，挂在它下面的**子任务会话**也要从本地列表一起消失。
      服务端（session.Delete）已经级联删了登记记录 / 日志 / 标题 / 状态；这里只是不让
@@ -4028,6 +4126,38 @@ button.setrow{font-family:inherit}
     else { b.style.cursor = 'default'; }
     body.appendChild(b);
   }
+  /* 单行文本输入抽屉（重命名 / 自定义路径共用）。
+     ⚠️ **不用 window.prompt**：悬浮球（Electron 小窗）与 Android WebView 都没实现它，
+        调用只会静默返回 null —— 表现就是「点击无效」且抽屉原样不动（2026-10-23 报障）。
+        这里换成抽屉里的真输入框，样式沿用启动页那套 .field / .btn；空值给红字提示，
+        不再静默 return（否则和上面的 bug 长得一模一样）。 */
+  function openTextInputSheet(opt, onOk) {
+    openHostSheet(opt.title || '', function (body) {
+      var f = hEl('div', 'field');
+      var inp = document.createElement('input');
+      inp.type = 'text';
+      inp.value = opt.value || '';
+      if (opt.placeholder) inp.placeholder = opt.placeholder;
+      inp.setAttribute('autocapitalize', 'off');
+      inp.setAttribute('autocorrect', 'off');
+      inp.setAttribute('spellcheck', 'false');
+      f.appendChild(inp);
+      body.appendChild(f);
+      var err = hEl('div', 'field__err'); err.hidden = true;
+      body.appendChild(err);
+      var ok = hEl('button', 'btn btn--filled', '确定'); ok.type = 'button';
+      body.appendChild(ok);
+      function commit() {
+        var v = String(inp.value || '').trim();
+        if (!v) { err.textContent = opt.emptyHint || '不能为空'; err.hidden = false; inp.focus(); return; }
+        closeHostSheet();
+        if (onOk) onOk(v);
+      }
+      ok.onclick = commit;
+      inp.onkeydown = function (e) { if (e.key === 'Enter') { e.preventDefault(); commit(); } };
+      setTimeout(function () { try { inp.focus(); inp.select(); } catch (e) {} }, 30);
+    });
+  }
   function applyWs() { if (conv && conv.setWorkspace) conv.setWorkspace(WS); }
   /* 工作空间值的显示：WS 为空 = 默认（不传 -w，core 用调用方 cwd）。
      ⚠️ **绝不显示目录名**（2026-10-21 用户：「默认就是要不属于任何空间目录」）。
@@ -4138,7 +4268,7 @@ button.setrow{font-family:inherit}
                  组件被销毁重建后，它的 owner='conv' 条目还留在 PENDING 里，由
                  adoptPendingFor 接回新实例 —— 状态只能落在条目上，不能只存在组件内存。 */
               owner: info.owner || 'gate',
-              hide: !!hide, dev: devKey(), at: Date.now() };
+              hide: !!hide, env: queueEnvKey(), dev: devKey(), at: Date.now() };
     PENDING.push(p); saveQueue();
     if (!hide) renderSessions(LAST_SESSIONS);
     return p;
@@ -4184,14 +4314,88 @@ button.setrow{font-family:inherit}
     delete QPEND[id];
     cancelPending(pid);          // 标取消 + 从 PENDING 与磁盘上一并删掉
   }
-  /* ── 队列落库 ──
-     键用**令牌**而不是地址：令牌是这台桌面的身份（magic-client 把它落盘复用，跨重启不变），
-     而地址会变 —— 手机从 Wi-Fi 切到热点、桌面换了 IP、端口变了，用地址当键就等于把上次的
-     排队任务判成「另一台机器的」而整批丢掉。换一台桌面来配对时令牌不同，自然互不干扰。
-     loadQueue 只认当前令牌那批，别的**留在原地不动**（那台机器再连上来时还能用）——
+  /* 服务端已受理（open 到达）：本地排队行交给服务端，删掉并清干净映射。 */
+  function clearPendingRow(id) {
+    if (!id) return;
+    Object.keys(QPEND).forEach(function (k) { if (QPEND[k] === id) delete QPEND[k]; });
+    ASK_WAITING = ASK_WAITING.filter(function (x) { return !x || x.id !== id; });
+    dropPending(id);
+  }
+  /* ── 把服务端作业队列接进对话组件（2026-10-23）──
+     · 每个 ask 都带 request_id：与本地排队行同一个 id，断线/重启/换标签页重发也只跑一次；
+     · 排队时服务端发 `event: queued`（老服务端没有，忽略）→ 把本地行翻成可见的「等待中」；
+     · `open` 到达 = 服务端已受理并开跑 → 删本地行。此后刷新页面也不会再重发。
+     老服务端（没有 jobs 能力）也照样带这些字段 —— 多出来的键会被忽略，行为不变。 */
+  function wrapTransportForJobs(t) {
+    if (!t || t.__jobsWrapped) return t;
+    t.__jobsWrapped = true;
+    var baseAsk = t.ask;
+    t.ask = function (payload, h) {
+      var p = payload || {};
+      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');
+      var hs = h || {};
+      var onOpen = hs.onOpen, onEvent = hs.onEvent, onEnd = hs.onEnd, onErr = hs.onError;
+      if (pend && !pend.gone) {
+        pend.dispatching = true;
+        pend.requestId = rid;
+        if (ASK_WAITING.indexOf(pend) < 0) ASK_WAITING.push(pend);
+      }
+      hs.onEvent = function (ev) {
+        if (ev && ev.state === 'queued' && pend && !pend.gone) {
+          if (ev.job) pend.job = ev.job;
+          pend.pos = ev.position || 0;
+          if (pend.hide) { pend.hide = false; renderSessions(LAST_SESSIONS); }
+          if (typeof pend.queuedCb === 'function') { try { pend.queuedCb(true); } catch (e) {} }
+        }
+        if (onEvent) { try { onEvent(ev); } catch (e) {} }
+      };
+      hs.onOpen = function (id) {
+        if (pend && !pend.gone) {
+          if (typeof pend.queuedCb === 'function') { try { pend.queuedCb(false); } catch (e) {} }
+          clearPendingRow(pend.id);
+        }
+        if (onOpen) { try { onOpen(id); } catch (e) {} }
+      };
+      hs.onEnd = function (code, ev) {
+        if (pend && !pend.gone) {
+          if (typeof pend.queuedCb === 'function') { try { pend.queuedCb(false); } catch (e) {} }
+          ASK_WAITING = ASK_WAITING.filter(function (x) { return x !== pend; });
+        }
+        if (onEnd) { try { onEnd(code, ev); } catch (e) {} }
+      };
+      hs.onError = function (e) {
+        /* 发不出去：本地行留着（下次连上 / 重开 App 由 restoreQueue 重发，request_id 不变）。 */
+        if (pend && !pend.gone) { pend.dispatching = false; }
+        if (onErr) { try { onErr(e); } catch (e2) {} }
+      };
+      return baseAsk.call(t, p, hs);
+    };
+    return t;
+  }
+  /* ── 队列落库（按**环境**分区）──
+     分区键用稳定 eid（见 ensureEnvId），与 ENV_SCOPE 同一口径；不是令牌也不是地址：
+       · 令牌会变 —— App 每次启动会换注入令牌，按令牌分桶等于每次重启换一个新桶；
+       · 令牌还会**重复** —— 多台桌面用同一枚显式 `--token` 部署时，按令牌分桶就把
+         A 的队列当成 B 的：切过去直接发到 B，而「A 的会话结束」事件还在 A，这边等不到；
+       · 地址也会变/会被复用 —— 按 host 分桶要么变孤儿，要么把旧任务发给后来占用
+         同一地址的另一台服务器。
+     loadQueue 只认当前环境那批，别的**留在原地不动**（切回去时接着跑）——
      所以这里是读改写，不是整体覆盖。 */
   var QUEUE_KEY = 'magic.serial.queue.v1';
+  function queueEnvKey() { return envScopeIdOf(activeConn()) || String(BASE || ''); }
+  /* 兼容旧行（没有 env、只有令牌派生的 dev）：只有令牌正好是当前这台时才认领 ——
+     认领后下一次写盘会补上 env。其余环境的行原样留着，等切回去再接。 */
   function devKey() { return String(TOKEN || '').slice(0, 12) || String(BASE || ''); }
+  function rowEnv(p) {
+    if (!p) return '';
+    if (p.env) return String(p.env);
+    if (p.dev && p.dev === devKey()) return queueEnvKey();
+    return '';
+  }
   function readQueueAll() {
     try {
       var a = JSON.parse(localStorage.getItem(QUEUE_KEY) || '[]');
@@ -4199,7 +4403,11 @@ button.setrow{font-family:inherit}
     } catch (e) { return []; }
   }
   function saveQueue() {
-    var mine = devKey(), others = readQueueAll().filter(function (p) { return p.dev !== mine; });
+    /* 没连上就不知道自己是哪台环境：此时宁可不写，也不能把「认不出归属」的行
+       当成自己的冲掉（那正是旧实现丢别的环境队列的方式）。 */
+    var mine = queueEnvKey();
+    if (!mine) return;
+    var others = readQueueAll().filter(function (p) { return rowEnv(p) !== mine; });
     /* 只落**持久**字段：hide / gone 是这一次页面会话里的显示态，存下去会让「关掉 App 时
        正好还没到 300ms」的那条永远隐藏 —— 队列里有它、列表上却看不见，最难查的一种。
        id 保留：恢复时据此与内存里已有的条目去重。 */
@@ -4212,13 +4420,41 @@ button.setrow{font-family:inherit}
                /* owner 刻意不落盘：重启后所有残留条目都由 restoreQueue 交给宿主
                   （enqueueDispatch），语义与 'host' 一致 —— 存下来反而会让「上次是
                   组件排队」的那条永远等不到组件接管。 */
-               dev: p.dev, at: p.at };
+               env: mine, dev: p.dev, at: p.at };
     });
     try { localStorage.setItem(QUEUE_KEY, JSON.stringify(others.concat(mineRows))); } catch (e) {}
+    queueBroadcast();
   }
   function loadQueue() {
-    var mine = devKey();
-    return readQueueAll().filter(function (p) { return p && p.dev === mine && p.prompt; });
+    var mine = queueEnvKey();
+    if (!mine) return [];
+    return readQueueAll().filter(function (p) { return p && rowEnv(p) === mine && p.prompt; });
+  }
+  /* 同源多标签页：队列变了就互相知会一声（真正的一致性由服务端负责，
+     这里只是让列表不用等下一次轮询才更新）。 */
+  var QUEUE_BC = null;
+  try { if (window.BroadcastChannel) QUEUE_BC = new BroadcastChannel('magic.queue'); } catch (e) { QUEUE_BC = null; }
+  function queueBroadcast() {
+    if (!QUEUE_BC) return;
+    try { QUEUE_BC.postMessage({ env: queueEnvKey(), at: Date.now() }); } catch (e) {}
+  }
+  function syncPendingFromDisk() {
+    var disk = loadQueue();
+    var keep = [];
+    PENDING.forEach(function (p) { if (p && (p.dispatching || p.owner === 'conv')) keep.push(p); });
+    var ids = {};
+    keep.forEach(function (p) { ids[p.id] = 1; });
+    PENDING = disk.filter(function (p) { return !ids[p.id]; }).concat(keep);
+    renderSessions(LAST_SESSIONS);
+  }
+  if (QUEUE_BC) {
+    try {
+      QUEUE_BC.onmessage = function (ev) {
+        var d = ev && ev.data;
+        if (!d || d.env !== queueEnvKey()) return;
+        try { syncPendingFromDisk(); } catch (e) {}
+      };
+    } catch (e) {}
   }
   /* 某条排队任务被用户放弃（划掉 / 删除）：磁盘上也要删，否则下次启动它又冒出来。 */
   function purgeQueue(id) {
@@ -4226,6 +4462,7 @@ button.setrow{font-family:inherit}
       var rest = readQueueAll().filter(function (p) { return p.id !== id; });
       localStorage.setItem(QUEUE_KEY, JSON.stringify(rest));
     } catch (e) {}
+    queueBroadcast();
   }
   /* 占位何时能还：等登记表里该空间真的出现这一条（= 它的 core 已落盘）。
      判据不能只看 `running`：几十毫秒就收工的任务，落盘那一刻起就不是 running 了，
@@ -4346,6 +4583,15 @@ button.setrow{font-family:inherit}
   function gateAsk(info) {
     if (TASK_MODE !== 'serial' || !info) return Promise.resolve(true);
     var ws = wsKey(info.workspace);
+    /* 服务端有作业队列：真正的「谁先跑」由服务端裁决（多客户端同一 workspace 串行），
+       宿主这里只把这条登记成本地行（关 App 后能恢复），然后立刻放行 ——
+       组件照常发 /desk/ask，服务端会先排队再开跑，排队时推 `queued` 事件回来。 */
+    if (SERVER_JOBS) {
+      var pend = addPending(ws, info, true);
+      ASK_WAITING.push(pend);
+      pend.queuedCb = (typeof info.queued === 'function') ? info.queued : null;
+      return Promise.resolve(true);
+    }
     var q = serialQ(ws);
     /* 落库是同步写，很便宜；而「点了发送、网还没回、用户退出了」正是丢任务的高危窗口，
        所以不等任何延时，先进队列进磁盘。 */
@@ -4405,6 +4651,19 @@ button.setrow{font-family:inherit}
     if (!hit) return false;
     hit.cancelled = true;
     hit.gone = true;
+    /* 服务端作业队列：排队中要把它从服务端撤掉，否则这边删了行、那边照样会开跑。
+       有 job id 走 job 路由；还没拿到（queued 事件未到）就按 request_id 撤。 */
+    if (SERVER_JOBS && (hit.job || hit.requestId || hit.id)) {
+      try {
+        var hdr = TOKEN ? { 'X-Magic-Token': TOKEN, 'Content-Type': 'application/json' } : { 'Content-Type': 'application/json' };
+        if (hit.job) {
+          fetch(BASE + '/desk/jobs/' + encodeURIComponent(hit.job) + '/cancel', { method: 'POST', headers: hdr }).catch(function () {});
+        } else {
+          fetch(BASE + '/desk/jobs/cancel', { method: 'POST', headers: hdr,
+            body: JSON.stringify({ request_id: hit.requestId || hit.id }) }).catch(function () {});
+        }
+      } catch (e) {}
+    }
     dropPending(id);
     renderSessions(LAST_SESSIONS);
     return true;
@@ -4454,7 +4713,62 @@ button.setrow{font-family:inherit}
     list.forEach(function (p) { p.owner = 'host'; });
     PENDING = list;
     renderSessions(LAST_SESSIONS);
-    list.forEach(function (p) { enqueueDispatch(p); });
+    if (!SERVER_JOBS) {
+      list.forEach(function (p) { enqueueDispatch(p); });
+      return;
+    }
+    /* 服务端作业队列：直接按 request_id 重新提交（幂等），提交成功才算交给服务端。
+       用 Web Locks 串行化「同源多标签页同时恢复」，避免两边各发一遍
+       —— 即使没有 Web Locks，服务端的 request_id 幂等也能兜住。 */
+    var submitAll = function () {
+      list.forEach(function (p) { submitQueuedJob(p); });
+    };
+    try {
+      if (navigator.locks && navigator.locks.request) {
+        navigator.locks.request('magic.queue.restore.' + queueEnvKey(), submitAll);
+      } else {
+        submitAll();
+      }
+    } catch (e) { submitAll(); }
+  }
+  /* 服务端作业提交：受理即删本地行（服务端接管，之后刷新/重开 App 都不会重发）。
+     失败则保留并标「未能启动」，下次连上由 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') };
+    if (p.model) body.model = p.model;
+    if (p.w) body.workspace = p.w;
+    if (p.session) body.session = p.session;
+    if (p.permission) body.permission = p.permission;
+    if (p.team) body.team = p.team;
+    if (p.hosted) body.hosted = true;
+    if (p.attachments && p.attachments.length) body.attachments = p.attachments;
+    var hdr = { 'Content-Type': 'application/json' };
+    if (TOKEN) hdr['X-Magic-Token'] = TOKEN;
+    return fetch(BASE + '/desk/jobs', { method: 'POST', headers: hdr, body: JSON.stringify(body) })
+      .then(function (r) {
+        if (!r.ok) {
+          return r.text().then(function (txt) {
+            var why = '';
+            try { var j = JSON.parse(txt); why = (j && j.error) || ''; } catch (e) {}
+            throw new Error(why || ('HTTP ' + r.status));
+          });
+        }
+        return r.json();
+      })
+      .then(function (out) {
+        if (!out || !out.job) return false;
+        if (p.stalled) { p.stalled = false; p.stalledReason = ''; }
+        dropPending(p.id);
+        if (typeof loadSessions === 'function') loadSessions(true);
+        return true;
+      })
+      .catch(function (e) {
+        p.stalled = true;
+        p.stalledReason = (e && e.message) || '网络错误';
+        renderSessions(LAST_SESSIONS);
+        return false;
+      });
   }
   function enqueueDispatch(p) {
     var ws = wsKey(p.w);
@@ -4761,13 +5075,19 @@ button.setrow{font-family:inherit}
         var isCustom = CUSTOM_SPACES.indexOf(w) >= 0;
         hRow(body, basename(w), isCustom ? '自定义' : null, function () { WS = w; saveWs(); applyWs(); closeHostSheet(); paintRunSettings(); }, false, WS === w);
       });
-      hRow(body, '自定义路径…', '＋', function () {
-        var p = window.prompt('输入工作空间的绝对路径', SPACES_ROOT || DW || '');
-        if (p == null) return;
-        p = p.trim(); if (!p) return;
-        if (CUSTOM_SPACES.indexOf(p) < 0) { CUSTOM_SPACES.push(p); saveSpaces(); }
-        WS = p; saveWs(); applyWs(); closeHostSheet(); loadSessions(); paintRunSettings();
-      });
+      hRow(body, '自定义路径…', '＋', openCustomPathSheet);
+    });
+  }
+  /* 自定义路径：复用单行输入抽屉（见 openTextInputSheet 上方的 prompt 说明）。 */
+  function openCustomPathSheet() {
+    openTextInputSheet({
+      title: '自定义路径',
+      value: SPACES_ROOT || DW || '',
+      placeholder: '/绝对路径',
+      emptyHint: '请输入工作空间的绝对路径'
+    }, function (p) {
+      if (CUSTOM_SPACES.indexOf(p) < 0) { CUSTOM_SPACES.push(p); saveSpaces(); }
+      WS = p; saveWs(); applyWs(); loadSessions(); paintRunSettings();
     });
   }
 
@@ -5186,9 +5506,9 @@ button.setrow{font-family:inherit}
     return el;
   }
   /* 「我的 → 建议引擎」：单列，首项「不开启」。不展示模型 —— 建议是纯文本短任务，
-     选模型只会让界面更复杂；core 对 llm 会自动挑不思考的变体。 */
+     选模型只会让界面更复杂；建议生成对 llm 会用不思考的变体作默认值。 */
   /* 「我的 → 建议引擎 / 模型」：与默认引擎同一个二列抽屉（左引擎 · 右模型）。
-     首项「不开启」；点左列只浏览、点右列才落定。llm 放最前，模型为空时 core 自动挑最快变体。 */
+     首项「不开启」；点左列只浏览、点右列才落定。llm 放最前，模型为空时建议生成用 no-think 变体作默认值。 */
   function openSuggestEnginePicker() {
     openHostSheet('建议引擎 / 模型', function (body) {
       body.innerHTML = '';
@@ -5218,12 +5538,12 @@ button.setrow{font-family:inherit}
           pick: pickSuggestPref,
           offLabel: '不开启',
           offDesc: '不生成下一轮建议（默认）',
-          modelDefaultDesc: '不指定模型（llm 会自动挑最快变体）',
+          modelDefaultDesc: '不指定模型（建议生成用 no-think 变体）',
         });
         /* 建议生成一律不思考。各引擎都走官方关闭参数；某些模型路由不支持时
            才在超时/报错后降级 llm，不预先吞掉用户的选择。 */
         var nk = hEl('div', 'history__hint',
-          '建议生成固定关闭思考：claude --thinking disabled、codex effort none、llm no-think / reasoning_effort、codebuddy alwaysThinkingEnabled=false、dsh reasoningEffort=off；引擎失败才降级 llm。');
+          '建议生成固定关闭思考：claude --thinking disabled、codex effort none、llm reasoning_effort=none（显式模型不换；空模型用 no-think 变体）、codebuddy alwaysThinkingEnabled=false、dsh reasoningEffort=off；引擎失败才降级 llm。');
         nk.style.textAlign = 'left';
         body.appendChild(nk);
       }, function (e) {
@@ -5654,7 +5974,9 @@ button.setrow{font-family:inherit}
           var tok = (lastUrl === injUrl && injectedToken)
             ? injectedToken : (sc.token || injectedToken);
           if (!tok) break;
-          BASE = sc.url; TOKEN = tok; ACTIVE_ID = sc.id;
+          BASE = sc.url; TOKEN = tok;
+          sc = ensureEnvId(sc) || sc;   // 老记录补 eid，并把按地址分区的旧队列/配置槽迁过来
+          ACTIVE_ID = sc.id;
           showHistory(sc.host || connHost(sc.url));
           restoreQueue();
           resumed = true;
@@ -5667,6 +5989,7 @@ button.setrow{font-family:inherit}
       /* 把当前这条（壳注入的）连接落成环境，名字默认「公司远程」——
          否则它只是一条改不了名、也留不住的「未命名」。 */
       seedCurrentConn();
+      ensureEnvId(activeConn());   // 种出来的这条也补 eid；seedoff 没落盘时按老键回退
       showHistory(injectedBase ? injectedBase.replace(/^https?:\/\//, '') : '本机');
       restoreQueue();      // App 重启：上次没轮到的排队任务接着排（见 restoreQueue）
     } else if (!resumed) {
@@ -5677,6 +6000,7 @@ button.setrow{font-family:inherit}
       all.sort(function (a, b) { return (b.at || 0) - (a.at || 0); });
       var pick = all[0];
       if (pick) {
+        pick = ensureEnvId(pick) || 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));