dsh-mobile-plugin 0.4.7 → 0.4.9

package/lib/mirror/pusher.cjs

@@ -21,6 +21,7 @@ const { listSignal: sharedListSignal } = require('../shared/list-signal.js');
 const { sessionSignal: sharedSessionSignal } = require('../shared/session-signal.js');
 const { dropSessionListCache } = require('../mobile/session-cache.js');
 const { observeCompletionEvent } = require('../mobile/completion.js');
+const { observeAutoContinue } = require('../mobile/auto-continue.js');
 const { lastTurnOf } = require('../mobile/session-last-turn.js');
 
 /** 后台循环每个 tick 补推一个冷会话，保证没人动的会话镜像也不长期不更新。 */
@@ -771,6 +772,9 @@ function createMirrorPusher(deps) {
           // session/stream 的 SSE 负责。不跳的话每条增量都要重建五份全量快照并推一次
           // sidecar，形成推送风暴（配合 pushSessionImmediately 的单飞才有稳定上界）。
           observeCompletionEvent(ctx, sessionId, p?.event);
+          // 手机发起的轮被输出 token 上限截断时代发一句「继续」（见 mobile/auto-continue.js）。
+          // 只认 turn/end，其余事件进来一行就退；它自己吞掉所有异常，不拖这条流。
+          void observeAutoContinue(ctx, sessionId, p?.event);
           if (p?.event?.type === 'assistant/chunk') continue;
           // iOS 推送：turn/end 是「可能刚收尾」的信号，把事实（lastTurnOf 现读）交给
           // 通知器判断——只有 completed / failed 且这一轮之前没推过才会真发一帧。

package/lib/mobile/auto-continue.js

@@ -0,0 +1,143 @@
+'use strict';
+
+/**
+ * 输出 token 用满之后替用户续一句「继续」。
+ *
+ * 宿主把 `finish=max-tokens` 折成 `turn/end(reason.kind='max-tokens')` 就收尾这一轮，
+ * 客户端只会画一行固定提示（桌面 `message.maxTokens` 那两句，App 侧是 `misc.structural.maxTokens`）
+ * ——要不要接着写是人的事。手机上这就等于每次长回答被截断，用户都得亲手打两个字；
+ * 而在手机上打字正是最费劲的那种操作。所以这里在宿主侧替他发这一句。
+ *
+ * 三条边界，缺一条就是替用户乱说话：
+ *
+ *   - **只续手机发起的轮**：会话里最后一条 user 消息必须带移动端 rpcId 前缀
+ *     （`mobile:`，与 `/session/send` 那条路同源，见 history-derive 的
+ *     `clientMessageIdFromSource`）。电脑上开的轮一动不动 —— 桌面那边用户本来就在键盘前。
+ *   - **一串最多续 {@link AUTO_CONTINUE_MAX_ROUNDS} 次**：真写满额度、或者思考死循环带出一段
+ *     可见正文时都会报 max-tokens（循环守卫只有在「思考是唯一产出」时才报 REASONING_LOOP），
+ *     无限续就是无限烧额度。续够次数就停手，把那一行提示留给用户。
+ *   - **同一轮只续一次**：事件流重连会重放 `turn/end`，不认这一条就是连发好几条「继续」。
+ *
+ * 续写走的是 `sessions.prompt`（与 App 的 `/session/send` 同一条路），所以它会作为一条
+ * 普通的 user 消息落进会话：用户看得见、能接着聊，也能据此判断「刚才那是它替我发的」。
+ */
+
+const { callSessions, mobilePromptRpcId } = require('./rpc.js');
+const { unwrap } = require('./envelope.js');
+const { clientMessageIdFromSource } = require('./history-derive.js');
+const { autoContinueTurnsOf } = require('./session-cache.js');
+
+/** 代发的那句话。短、明确、不夹带额外指令 —— 模型看见的就是用户会打的那两个字。 */
+const AUTO_CONTINUE_TEXT = '继续';
+
+/**
+ * 一串里最多代发几次。
+ *
+ * 三次是「够写完一篇长答复」与「别在病态输出上无限烧额度」之间的折中：按 8192 输出上限
+ * 算，四次加总三万多 token，正常长文到这已经写完了。
+ */
+const AUTO_CONTINUE_MAX_ROUNDS = 3;
+
+/**
+ * 代发消息的 clientMessageId 前缀。
+ *
+ * 它同时是**认回自己**的唯一凭据：这一串续了几次不另开计数器，而是回读会话里最后几条
+ * user 消息数连续的那几条 —— 宿主重启、事件重放、用户中途插话，三种情况都不会数错。
+ */
+const AUTO_CONTINUE_CLIENT_PREFIX = 'auto-continue-';
+
+/** 回读会话时取的消息条数：只要够看到「上一个人类发言」，不必读全量。 */
+const HISTORY_MESSAGE_LIMIT = 40;
+
+/** 这条 user 消息是不是我们自己代发的。 */
+function isAutoContinueId(clientMessageId) {
+  return typeof clientMessageId === 'string' && clientMessageId.startsWith(AUTO_CONTINUE_CLIENT_PREFIX);
+}
+
+/**
+ * 数「这一轮是手机发起的吗」「这一串已经代发了几次」。
+ *
+ * 返回 `{ rounds }` 表示可以续（`rounds` 是已续次数）；`null` 表示这一轮不该续
+ * —— 最后一条人类发言不是从手机来的，或者压根读不到会话。
+ *
+ * 只认**最后一条非代发的 user 消息**：它是这一轮的起点。中点插话（steer）也是 user 消息，
+ * 它同样带移动端 rpcId，所以「手机上补一句」不会把宿主判成「这是电脑开的轮」。
+ */
+async function chainState(ctx, sessionId) {
+  const response = await callSessions(ctx, 'history', { sessionId, maxMessages: HISTORY_MESSAGE_LIMIT });
+  const result = unwrap(response);
+  if (result.error) return null;
+  const events = (result.value && Array.isArray(result.value.events)) ? result.value.events : [];
+
+  let rounds = 0;
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const entry = events[index];
+    const event = entry && entry.event ? entry.event : entry;
+    if (!event || event.type !== 'user/message' || !event.data) continue;
+    const clientMessageId = clientMessageIdFromSource(event.data.source, event.data);
+    if (isAutoContinueId(clientMessageId)) {
+      rounds += 1;
+      continue;
+    }
+    // 收起循环：第一条不是我们代发的 user 消息就是这一轮的起点。
+    if (clientMessageId === undefined) return null;
+    return { rounds };
+  }
+  return null;
+}
+
+/**
+ * 发那一句「继续」。
+ *
+ * `requestId` 必须走 `mobilePromptRpcId`：宿主要把它写进 user 消息的 `source.rpcId`，
+ * 上面的 `chainState` 才能在下一轮认出「这条是我们发的」，App 也能把它当成本设备发的消息
+ * 认领（否则手机上会同时出现一条乐观行和一条来历不明的消息）。
+ */
+function sendContinue(ctx, sessionId, turn, round) {
+  const clientMessageId = `${AUTO_CONTINUE_CLIENT_PREFIX}${turn}-${round}`;
+  const rpcId = mobilePromptRpcId(clientMessageId);
+  return callSessions(ctx, 'prompt', {
+    sessionId,
+    requestId: rpcId,
+    content: [{ type: 'text', text: AUTO_CONTINUE_TEXT }],
+  }, rpcId);
+}
+
+/**
+ * 吃一条宿主会话事件；是「手机发起的这一轮被输出上限截断了」就代发一句「继续」。
+ *
+ * 由镜像推送那条全局事件循环调用（`lib/mirror/pusher.cjs`，与 `observeCompletionEvent` 同一处）。
+ * **绝不抛**：它是事件循环里的一步，抛出去会把镜像推送整条流带走；代发失败没有代价
+ * ——那一行「已达到输出 token 上限」照旧在界面上，用户还能自己点。
+ *
+ * @returns {Promise<boolean>} 是否真的代发了一条（给守卫用）。
+ */
+async function observeAutoContinue(ctx, sessionId, event) {
+  if (!sessionId || !event || event.type !== 'turn/end') return false;
+  const data = event.data;
+  if (!data || typeof data.turn !== 'number') return false;
+  if (!data.reason || data.reason.kind !== 'max-tokens') return false;
+
+  const turn = data.turn;
+  const map = autoContinueTurnsOf(ctx);
+  if (map.get(sessionId) === turn) return false; // 这一轮已经代发过（事件重放）
+  // 先占位再 await：同一轮的 turn/end 可能在历史读完之前又到一条。
+  map.set(sessionId, turn);
+  try {
+    const chain = await chainState(ctx, sessionId);
+    if (!chain || chain.rounds >= AUTO_CONTINUE_MAX_ROUNDS) return false;
+    await sendContinue(ctx, sessionId, turn, chain.rounds);
+    return true;
+  } catch {
+    // 占位撤掉：这一发是网络 / 网关的瞬时失败，下一次同类事件还该再试一次。
+    if (map.get(sessionId) === turn) map.delete(sessionId);
+    return false;
+  }
+}
+
+module.exports = {
+  AUTO_CONTINUE_TEXT,
+  AUTO_CONTINUE_MAX_ROUNDS,
+  AUTO_CONTINUE_CLIENT_PREFIX,
+  observeAutoContinue,
+};

package/lib/mobile/history-derive.js

@@ -757,6 +757,13 @@ function deriveMessages(events) {
       if (bucket && bucket.size > 0) item.producedFiles = [...bucket];
     }
   }
+  // 压缩行带一个空正文：直播侧的同款行本来就带 `text: ''`（App 的 `structuralItems`
+  // 一条不落），历史这边少这一格时，没跟上判空修复的旧安装包会在这条行上直接读正文、
+  // 当场抛错、整页崩掉（2026-10-27 真机）。标题与摘要照旧按 kind 走，不读这个字段；
+  // 其它结构行刻意不带（与 `history-turn-end` 守卫钉的形状一致）。
+  for (const item of out) {
+    if (item.kind === 'compaction' && typeof item.text !== 'string') item.text = '';
+  }
   // 严格按事件 seq 升序（与消息混排；compaction 行升级/替换后位置以最终事件为准）。
   out.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
   return out;

package/lib/mobile/plugin-update.js

@@ -18,7 +18,7 @@
 const path = require('node:path');
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { checkForUpdate } = require('../update-registry.cjs');
-const { declaredSource } = require('../update-install.cjs');
+const { declaredSource, profileRegistry } = require('../update-install.cjs');
 const { version: generationVersion } = require('../../package.json');
 
 /** apply 的请求体只有 `force` 一个布尔，给 4KB 都很宽。 */
@@ -113,9 +113,24 @@ async function handlePluginUpdateStatus(ctx, _req, res) {
 async function handlePluginUpdateCheck(ctx, _req, res) {
   const status = snapshot(ctx);
   try {
+    // 与装用同一个源：问这台机器上 pnpm 真正在用的注册表（镜像 / 私有源机器上，写死官方源
+    // 等于永远查不到）。问不到才退回官方源。
+    const runtime = runtimeOf(ctx);
+    const live = runtime && typeof runtime.status === 'function' ? runtime.status() : null;
+    let packageManager = null;
+    try {
+      packageManager = typeof ctx?.get === 'function' ? ctx.get('profileContext')?.packageManager ?? null : null;
+    } catch {
+      packageManager = null;
+    }
+    const registry = await profileRegistry({
+      profileNodeModules: typeof live?.profileNodeModules === 'string' ? live.profileNodeModules : null,
+      packageManager,
+    });
     const update = await checkForUpdate({
       installedVersion: status.installedVersion ?? status.runningVersion ?? generationVersion,
       source: status.source,
+      base: registry ?? undefined,
     });
     sendJson(res, 200, { ok: true, update, status });
   } catch (error) {

package/lib/mobile/session-cache.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * 会话侧的按 ctx 隔离状态：十三张表，一个入口。
+ * 会话侧的按 ctx 隔离状态：十四张表，一个入口。
  *
  * 这些表此前全是 sessions.js 的模块级 WeakMap。它们之所以必须按 ctx 隔离，是因为
  * 它们的值属于**宿主进程状态**（某个会话正在跑、某个列表刚构建完、某条发送已经
@@ -47,6 +47,10 @@ const writeIdempotency = new WeakMap();
 // 与 sessionListResponseCache 同一类东西（列表刚构建完的那份是谁），只是按工作区算。
 const workspaceShortcutStates = new WeakMap();
 
+// 输出 token 用满之后「这一轮已经替用户代发过『继续』」的记账（见 mobile/auto-continue.js）。
+// 只用来挡事件流重连的重放；续了几次由会话历史数出来，不放这里。
+const autoContinueTurns = new WeakMap();
+
 /** 设备维度：同一个 ctx 下多台手机各自一份，缺省用 'legacy'（未带 x-dsh-device 的调用）。 */
 function canonicalDeviceKey(req, fallback = 'legacy') {
   const value = req?.headers?.['x-dsh-device'];
@@ -241,6 +245,21 @@ function workspaceShortcutStateOf(ctx) {
   return state;
 }
 
+/**
+ * 「这一轮已经替用户代发过『继续』」的记账：sessionId → 轮次。
+ *
+ * 只挡事件流重连的重放（同一轮会到两条 `turn/end`），不做次数上限 —— 次数由会话历史里
+ * 连续的代发消息数出来，见 `mobile/auto-continue.js` 的文件头。
+ */
+function autoContinueTurnsOf(ctx) {
+  let turns = autoContinueTurns.get(ctx);
+  if (!turns) {
+    turns = new Map();
+    autoContinueTurns.set(ctx, turns);
+  }
+  return turns;
+}
+
 function completionGenerationOf(ctx, deviceKey) {
   let generations = completionGenerations.get(ctx);
   if (!generations) {
@@ -387,6 +406,7 @@ module.exports = {
   clearCompletionForAllDevices,
   completionGenerationOf,
   workspaceShortcutStateOf,
+  autoContinueTurnsOf,
   bumpCompletionGeneration,
   sendIdempotencyStateOf,
   promptOnceFor,

package/lib/reconnect-scheduler.cjs

@@ -38,13 +38,26 @@ function createReconnectScheduler({
   let timer = null
   let misses = 0
   return {
-    /** 排程一次重连；已有待触发的定时器时返回 false，表示被幂等吸收。 */
-    schedule() {
+    /**
+     * 排程一次重连；已有待触发的定时器时返回 false，表示被幂等吸收。
+     *
+     * `overrideMs` 是「这台不是坏了、是被人挡在门外」那类失败的专用间隔（目前只有中转回的
+     * `plugin_too_old`）：它绕开指数退避、也不吃 `maxDelayMs` 的封顶。给一个固定间隔而不是
+     * 退避，是因为窗口是按「人去更新插件」量级的，翻倍退避在这一档上没有意义。
+     */
+    schedule(overrideMs) {
       if (timer !== null) return false
-      const backoff = misses === 0 ? 1 : 2 ** Math.min(misses, BACKOFF_EXP_CAP)
-      const base = Math.min(delayMs * backoff, maxDelayMs)
-      const wait = base + (jitterMs > 0 ? Math.floor(random() * jitterMs) : 0)
-      misses += 1
+      let wait
+      if (typeof overrideMs === 'number' && overrideMs > 0) {
+        wait = overrideMs + (jitterMs > 0 ? Math.floor(random() * jitterMs) : 0)
+      } else {
+        const backoff = misses === 0 ? 1 : 2 ** Math.min(misses, BACKOFF_EXP_CAP)
+        const base = Math.min(delayMs * backoff, maxDelayMs)
+        wait = base + (jitterMs > 0 ? Math.floor(random() * jitterMs) : 0)
+        // 指定间隔那一档**不动这笔账**：它不是「连续失败」，不该把之后正常的掉线重连
+        // 一起推成 10s、20s。被版本挡住之后再恢复，仍要从 5s 起算。
+        misses += 1
+      }
       timer = setTimer(() => { timer = null; onFire() }, wait)
       return true
     },

package/lib/relay/tunnel.js

@@ -17,6 +17,10 @@ const { isFreshRequest } = require('../shared/fresh-request');
 const { encodeJsonBody } = require('../shared/http-util');
 const { withViaHeader } = require('../shared/via-header');
 
+// 上报给中转的插件版本：只有包自己的 package.json 这一个来源（与 lib/relay/status.js 同口径）。
+// 中转靠它判「这台宿主是不是太旧」，见 relay-core 的 PROTOCOL.md 的 register 那行。
+const { version: PLUGIN_VERSION } = require('../../package.json');
+
 const HEARTBEAT_INTERVAL_MS = 15_000;
 // 中转 60s 收不到 pong 就把这条隧道 terminate 掉（TUNNEL_PONG_TIMEOUT_MS）。宿主必须比它
 // 先动或同时动：反过来就是「被踢的那一刻我们还以为连着」，那段时间手机发来的每个请求都要
@@ -91,6 +95,10 @@ class RelayTunnel {
     // 不差。纯转发节点（`MIRROR_CACHE=0`）收下整份镜像也只解析完丢掉，worker 据此只把
     // 摘要推上去（lib/sidecar-facade-worker.cjs 的 digestFrame）。
     this.relayMirror = true;
+    // 中转在注册阶段拒绝时回的那条控制帧（`code`/`message`）。宿主据此把「版本过旧」和
+    // 「连不上」分开：两件事的重连节奏差三个数量级（见 sidecar-facade-worker 的
+    // OUTDATED_RETRY_MS），混在一起就会拿 5 秒退避一路撞门。
+    this.lastControlError = null;
     // 清除所有授权的等待回调（一次一个）；由 requestRevokeAll 注入，revokeAllAck 触发。
     this._revokeAllAck = null;
   }
@@ -405,6 +413,8 @@ class RelayTunnel {
     return {
       instanceId: this.instanceId,
       name: this.name,
+      // 中转用它判版本门槛（MIN_PLUGIN_VERSION）；老中转不读它，多一个字段没有影响。
+      version: PLUGIN_VERSION,
       // 可选：与中转端 TUNNEL_REGISTER_SECRET 对应，防止他人抢注 instanceId。
       ...(this.registerSecret ? { secret: this.registerSecret } : {}),
       ...(this.lanUrls.length ? { lanUrls: this.lanUrls } : {}),
@@ -469,6 +479,7 @@ class RelayTunnel {
     // 每条新连接都从「对端存镜像」重新判定：能走到推送的那一步一定已经收到过回执，
     // 而回执缺这个字段的老中转本来就该按「存」处理。
     this.relayMirror = true;
+    this.lastControlError = null;
     return new Promise((resolve, reject) => {
       let settled = false;
       const done = (fn, arg) => {
@@ -520,7 +531,15 @@ class RelayTunnel {
         this.cancelledHttp.clear();
         this.cancelledWs.clear();
         this.onClose(code, reason);
-        done(reject, new Error(`隧道关闭: ${code} ${reason}`));
+        const closed = new Error(`隧道关闭: ${code} ${reason}`);
+        // 中转在关掉之前说过原因（比如「插件太旧」）就把它挂到 error 上：调用方要按 code
+        // 分流重连节奏，别把「被拒」当成「网络不好」按 5 秒退避一路撞下去。
+        if (this.lastControlError && typeof this.lastControlError.code === 'string') {
+          closed.code = this.lastControlError.code;
+          closed.pluginMessage = this.lastControlError.message || '';
+          closed.retryAfterMs = Number(this.lastControlError.retryAfterMs) || 0;
+        }
+        done(reject, closed);
       });
       ws.on('error', (err) => {
         clearTimeout(timer);
@@ -573,6 +592,12 @@ class RelayTunnel {
   // ── 帧分发 ────────────────────────────────────────────────────────
   handleFrame(frame) {
     const { type, id, payload } = frame;
+    // id=0 的 wsError 是中转在断开之前给的一句话（现在还只用于「注册被拒」）：先记下来，
+    // 等随后的 close 回调把它带进 start() 的 reject，调用方按 `code` 分流。
+    if (type === T.wsError && id === 0) {
+      this.lastControlError = parseJson(payload);
+      return;
+    }
     switch (type) {
       case T.httpRequest: {
         const msg = parseJson(payload);

package/lib/routes/control-plane.js

@@ -44,7 +44,7 @@ const { createSelfCheck } = require('../mobile/self-check.cjs');
 // 「查有没有新版」与「装新版」这两格都归插件自己：查直接问 npm 注册表，装在 profile 里跑
 // 它自己的包管理器（见 `../update-registry.cjs` / `../update-install.cjs`）。不再借道市场。
 const { checkForUpdate } = require('../update-registry.cjs');
-const { declaredSource } = require('../update-install.cjs');
+const { declaredSource, profileRegistry } = require('../update-install.cjs');
 const { clearCompletionForAllDevices, invalidateSessionList } = require('../mobile/session-cache.js');
 const { recordSessionRead } = require('../mobile/session-last-turn.js');
 // 收件目录的占用与清理：和移动端那条路由是同一份实现（`lib/mobile/inbox-clean.js`）。
@@ -253,6 +253,19 @@ function registerControlPlaneRoutes(deps) {
      */
     dropDeviceStreams = () => 0,
   } = deps;
+  /**
+   * 宿主发布的包管理器调用方式（`profileContext.packageManager`）。
+   *
+   * 「查更新」要用它去问这台机器上 pnpm 真正在用的注册表；拿不到就当没有（退回官方源），
+   * 不影响其它路由。
+   */
+  const profilePackageManager = () => {
+    try {
+      return typeof ctx?.get === 'function' ? ctx.get('profileContext')?.packageManager ?? null : null
+    } catch {
+      return null
+    }
+  }
   const selfCheck = createSelfCheck({
     ctx,
     credentials,
@@ -730,11 +743,18 @@ function registerControlPlaneRoutes(deps) {
     // 卡片当场从「宿主模式」掉进取降级那一半 —— 用户看到的现象是「有新版本却没有『立即更新』」。
     const snapshot = runtime ? { available: true, ...runtime.status() } : null
     try {
+      // 查也跟装用同一个源：问这台机器上 pnpm 真正在用的注册表（镜像 / 私有源机器上，
+      // 写死官方源等于永远查不到）。问不到才退回官方源。
+      const registry = await profileRegistry({
+        profileNodeModules: typeof snapshot?.profileNodeModules === 'string' ? snapshot.profileNodeModules : null,
+        packageManager: profilePackageManager(),
+      })
       const update = await checkForUpdate({
         installedVersion: snapshot?.installedVersion ?? snapshot?.version ?? generationVersion(),
         // 「安装来源」也自己看：profile 的依赖声明里写的是什么（npm / file: / link:）。读不到
         // 才退回外壳上次问市场的记忆 —— 这条路上不为它去敲市场。
         source: declaredSource(snapshot?.profileNodeModules ? path.dirname(snapshot.profileNodeModules) : null) ?? snapshot?.marketResult?.source ?? null,
+        base: registry ?? undefined,
       })
       return sendJson(res, 200, { ok: true, data: { update, status: snapshot } })
     } catch (error) {

package/lib/sidecar-facade-worker.cjs

@@ -89,6 +89,37 @@ const reconnect = createReconnectScheduler({
   onFire: () => startTunnel(),
 })
 
+/**
+ * 被中转按「插件太旧」挡下来时的重连间隔。
+ *
+ * 这一档不是故障：链路是通的，是这台的插件版本低于中转的门槛（`MIN_PLUGIN_VERSION`）。
+ * 按 5 秒退避重连一点用都没有——门槛不会因为多敲几次就降下来，而所有老宿主一起敲会把
+ * 中转的握手与日志刷满。半小时一次既能让「装上新版之后半小时内自动恢复」，也不会给中转
+ * 添负担。宿主重启（装完插件之后通常就是重启 DSH）会立刻重来一次。
+ */
+const OUTDATED_RETRY_MS = 30 * 60 * 1000
+
+/**
+ * 被中转以「插件太旧」挡下来时的收尾：状态另立成 `outdated`、记录那句话、三十分钟后再试。
+ *
+ * 单独成函数而不是散在两处回调里，是因为它必须**带实例身份闸**（`telemetry` 之外的任何
+ * 状态写入点都要），而回调里那一行闸只管得到紧挨着的那一句；收成一个有闸的入口，
+ * 两处调用就都只有一行、也不会漏。
+ *
+ * 返回 true 表示这一轮已经按「版本过旧」处理完了，调用方别再走普通断线那条路。
+ */
+function markOutdated(current) {
+  if (tunnel !== current) return true
+  const info = (current && current.lastControlError) || null
+  if (!info || info.code !== 'plugin_too_old') return false
+  tunnelState = 'outdated'
+  tunnelError = info.message || '插件版本过旧，请更新'
+  publishState()
+  reconnect.cancel()
+  reconnect.schedule(OUTDATED_RETRY_MS)
+  return true
+}
+
 function send(res, code, value) {
   if (res.headersSent) return res.end()
   res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
@@ -336,7 +367,13 @@ function openTunnel() {
       if (tunnel !== current) return; reconnect.reset()
       tunnelState = 'connected'; tunnelError = null; relayMirror = current.relayMirror !== false; publishState()
     },
-    onClose: () => { if (tunnel === current && config.enabled) { tunnelState = 'error'; tunnelError = '连接断开'; publishState(); scheduleReconnect() } },
+    onClose: () => {
+      if (tunnel !== current || !config.enabled) return
+      tunnelState = 'error'; tunnelError = '连接断开'; publishState(); scheduleReconnect()
+      // 中转在关掉之前说过「插件太旧」的话，这一档要改口径：状态另立成 outdated、复位成
+      // 三十分钟一次。markOutdated 自带实例身份闸，改完直接盖掉上面那句「连接断开」。
+      markOutdated(current)
+    },
     onPairRequest: async (message) => {
       try {
         const result = await parentJson('/api/relay/internal/approval', { device: message.device || {} })
@@ -351,7 +388,12 @@ function openTunnel() {
   const ready = current.start()
   // 挂了就如实报，并按 5s 起退避重连（旧实现在 startTunnel 的 catch 里做同一件事）。
   // 换地址失败时这里也会排一次：配置里已经是新地址，值得继续试它，而不是悄悄退回旧地址。
-  ready.catch(error => { if (tunnel === current) { tunnelState = 'error'; tunnelError = error instanceof Error ? error.message : String(error); publishState(); scheduleReconnect() } })
+  ready.catch(error => {
+    if (tunnel !== current) return
+    tunnelState = 'error'; tunnelError = error instanceof Error ? error.message : String(error); publishState(); scheduleReconnect()
+    // 与 onClose 同一套判据：被中转挡住（版本过旧）时改写状态并改排三十分钟，别落进 5 秒退避。
+    markOutdated(current)
+  })
   return ready
 }
 function startTunnel() {

package/lib/update-install.cjs

@@ -7,16 +7,26 @@
  * 另一个插件没装、太老或坏了就整个失效。
  *
  * 不自己实现包管理，只驱动它：profile 的 pnpm-workspace.yaml 已经写好 node-linker、peer 等
- * 关键设置，这里只「cd 到 profile 跑一句 pnpm add <包名>@<版本>」，不传布局类开关。三处必要
- * 的开关：auto-install-peers=false（peer 是运行时注入的，npm 上没有）、CI=1（无终端），以及
- * 撞上 pnpm「新发布先晾一会儿」时带 minimum-release-age=0 重试一次（那道策略查整份 lockfile，
- * 别的插件刚发也会连累我们）。
+ * 关键设置，这里只「cd 到 profile 跑一句 pnpm add <包名>@<版本>」，不传布局类开关。必要的
+ * 开关有两层：auto-install-peers=false（peer 是运行时注入的，npm 上没有）、minimum-release-age=0
+ * （2026-10-26 用户要求一检测到新版就立刻装，不等「新发布先晾一会儿」；那道策略查的是整份
+ * lockfile，别的插件刚发也会连累我们），再加上 CI=1（无终端）。命令行带一份、环境变量再带一份：
+ * pnpm 12 的原生 CLI 会静默忽略这两个 --config 参数，环境变量那一份还认。
+ *
+ * 装完要**登记**：这个版本是被我们绕过晾置期装进去的，不写进 profile 的 minimumReleaseAgeExclude，
+ * 它就会留在 lockfile 里，之后 pnpm 校验整份 lockfile 时把这台机器上所有安装都拒掉
+ * （官方桌面端不替用户临时放行，只能干等 24 小时）。
  *
  * 包管理器优先用宿主发布的那个（profile 是宿主自带 pnpm 装的，PATH 上版本不同会
  * ERR_PNPM_UNEXPECTED_STORE），找不到再退回 PATH。装之前先看有没有 agent 在跑；force 与 auto
- * 都跳过这道闸、也都不等发布晾置期（2026-10-26 用户要求自动更新一检测到新版就立刻装，与面板
- * 上那颗「强制更新」同一个口径），两者的区别只剩「没新版时装不装」。顺序上先答「有没有新版」，
- * 没东西可装时不该拿「有对话在跑」挡在前面。
+ * 都跳过这道闸（2026-10-26 用户要求自动更新一检测到新版就立刻装，与面板上那颗「强制更新」
+ * 同一个口径），两者的区别只剩「没新版时装不装」。顺序上先答「有没有新版」，没东西可装时
+ * 不该拿「有对话在跑」挡在前面。
+ *
+ * 宿主环境对不上时先修一次再重试：node_modules 是旧版 pnpm 建的（两个 hoist 相关的
+ * ERR_PNPM_*_DIFF）就重建依赖树；记录的 store 和现在解析的不是同一个（ERR_PNPM_UNEXPECTED_STORE）
+ * 就把记录里的那个 store 写回 profile 的 storeDir。两种都只修一次，修不了就如实失败 —— 这类
+ * 现场不修的话，这台机器之后每一次更新都会撞同一堵墙。
  *
  * 只动 profile 的依赖树；找不到包管理器就如实失败；装完以盘上版本号为准，退出码 0 不算装上。
  */
@@ -34,6 +44,9 @@ const DEFAULT_NAME = 'dsh-mobile-plugin';
 /** 一次安装的上限：pnpm 装一个包 + 拉依赖，给足但别无限等。 */
 const INSTALL_TIMEOUT_MS = 10 * 60 * 1000;
 
+/** 依赖树是旧版 pnpm 建的：这两种报错都只说明「要重建」，不是这一版有问题。 */
+const HOIST_DIFF = /ERR_PNPM_PUBLIC_HOIST_PATTERN_DIFF|ERR_PNPM_VIRTUAL_STORE_DIR_MAX_LENGTH_DIFF/;
+
 /** 命令输出留多少字符（日志与错误信息里给个人看得懂的尾巴）。 */
 const OUTPUT_TAIL = 4000;
 
@@ -88,6 +101,90 @@ function spawnEnv(dirs, env = process.env) {
   return { ...env, PATH: [...dirs, ...existing].join(path.delimiter), CI: env.CI || '1' };
 }
 
+/**
+ * 每次调 pnpm 都带上的那两格策略开关，**环境变量这一份不是备份，是另一半**。
+ *
+ * pnpm 11 两种写法都认；pnpm 12 的原生 CLI 会静默忽略部分 `--config.*`（市场在 #600 上实测
+ * 过，一次装失败一次白等），但同一个键走 `PNPM_CONFIG_*` 它照读。命令行与环境变量各带一份，
+ * 换哪个大版本都不用重新猜。
+ */
+const POLICY_ENV = {
+  PNPM_CONFIG_AUTO_INSTALL_PEERS: 'false',
+  PNPM_CONFIG_MINIMUM_RELEASE_AGE: '0',
+};
+
+/** 「配置里这个包用的是哪个注册表」缓存多久：查更新两分钟一轮，源不常换。 */
+const REGISTRY_CACHE_MS = 5 * 60 * 1000;
+
+/** profile 目录 → 上一次问到的注册表（问不到也记，省得每轮重跑一次包管理器）。 */
+const registryCache = new Map();
+
+/**
+ * 从 `<pm> config get registry` 的输出里取地址。
+ *
+ * pnpm / npm 都只回一行地址；升级提示、警告可能在前面，所以从后往前找第一个 http(s) 行。
+ */
+function parseRegistryOutput(output) {
+  const lines = String(output || '').split('\n').map(line => line.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (/^https?:\/\/\S+$/.test(lines[i])) return lines[i].replace(/\/+$/, '');
+  }
+  return null;
+}
+
+/**
+ * 这台机器上 pnpm / npm 真正会用的注册表。
+ *
+ * 问的是包管理器自己（`config get registry`），不是我们读文件猜：registry 可能来自 profile 的
+ * `.npmrc`、用户级 rc、pnpm-workspace.yaml 的 registries，还可以是环境变量改的 —— 只有它自己
+ * 的解析链能给出同一个答案。查更新与真正安装因此走同一个源，不会「查得到、装不上」，也是
+ * 镜像 / 私有源机器上自动更新还能自己动的前提。
+ *
+ * 拿不到（没有包管理器、命令超时、输出里没有地址）就回 null，调用方退回官方源：
+ * 这条链上多一次探测不该把「检查更新」变成不可用。`DSHM_NPM_REGISTRY` 显式给了值时不探，
+ * 那是给人排查 / 私有部署用的最高优先级。
+ */
+async function profileRegistry({
+  profileNodeModules,
+  packageManager = null,
+  env = process.env,
+  platform = process.platform,
+  dirs = null,
+  timeoutMs = 20000,
+  cache = registryCache,
+  now = Date.now,
+} = {}) {
+  // `DSHM_NPM_REGISTRY` 显式给了值就不探：那是给人排查 / 私有部署用的最高优先级，
+  // 而且查更新那一半读的是进程环境，这里不能只看子进程那一份。
+  const override = String(env.DSHM_NPM_REGISTRY || process.env.DSHM_NPM_REGISTRY || '').trim();
+  if (!profileNodeModules || override !== '') return null;
+  const profileDir = path.dirname(profileNodeModules);
+  const hit = cache.get(profileDir);
+  if (hit && now() - hit.at < REGISTRY_CACHE_MS) return hit.registry;
+  const searchDirs = dirs ?? toolSearchDirs({ platform, env });
+  const childEnv = spawnEnv(searchDirs, env);
+  const hostInvocation = normalizeInvocation(packageManager);
+  const candidates = [];
+  if (hostInvocation) candidates.push({ command: hostInvocation.command, prefix: hostInvocation.args, extraEnv: hostInvocation.env });
+  const pnpm = resolveExecutable('pnpm', searchDirs, { platform, env });
+  if (pnpm) candidates.push({ command: pnpm, prefix: [], extraEnv: {} });
+  const npm = resolveExecutable('npm', searchDirs, { platform, env });
+  if (npm) candidates.push({ command: npm, prefix: [], extraEnv: {} });
+  let registry = null;
+  for (const candidate of candidates) {
+    const result = await run(candidate.command, [...candidate.prefix, 'config', 'get', 'registry'], {
+      cwd: profileDir,
+      env: { ...childEnv, ...candidate.extraEnv },
+      timeoutMs,
+    });
+    if (!result.ok) continue;
+    registry = parseRegistryOutput(result.output);
+    if (registry) break;
+  }
+  cache.set(profileDir, { at: now(), registry });
+  return registry;
+}
+
 /** profile 里装着的那份插件包的版本号（读不到返回 null）。 */
 function installedVersion(profileNodeModules, name = DEFAULT_NAME) {
   try {
@@ -155,7 +252,136 @@ function installAllowedFor(source) {
 }
 
 /**
- * 宿主**发布出来**的包管理器调用方式（DSH 桌面版把它挂在 `profileContext.packageManager`
+ * 把一条「这一版是我故意装的」写进 profile 的 `minimumReleaseAgeExclude`。
+ *
+ * 为什么非要写：我们是用一次性开关把 24 小时内的版本装进去的，那个开关只对那一条命令生效。
+ * 这一版随后留在 lockfile 里，pnpm 11 在**任何** add / remove 之前都会拿当前策略校验整份
+ * lockfile —— 官方桌面端不替用户临时放行，于是这台机器上所有插件安装都要干等到它满 24 小时，
+ * 报错还会点名我们这个包。写进去就是把「我信任这一版」这件事落在配置里，撤销的代价只有一行。
+ *
+ * 规则跟市场那边一致：**同名只读第一条**（pnpm 的 #883），所以必须并进已有的那一行，
+ * 不能另起一行；条目可以是 `name@v || name@v2`，也可能是带引号的。单行的 flow 写法
+ * （`minimumReleaseAgeExclude: [a, b]`）不碰 —— 改坏了比不写更贵，而 pnpm 自己写出来的是块形式。
+ *
+ * 失败一律返回 false，不抛：登记是善后，不是更新本身，它出问题不该把装好的版本说成没装上。
+ */
+function recordReleaseAgeExclusion(profileDir, name, version) {
+  const file = path.join(profileDir, 'pnpm-workspace.yaml');
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    // 没有 workspace 文件就什么都不做：替人发明一个会改掉 pnpm 认的 workspace 根。
+    return false;
+  }
+  const lines = text.split('\n');
+  const at = lines.findIndex(line => /^minimumReleaseAgeExclude\s*:/.test(line));
+  if (at !== -1) {
+    const inline = lines[at].replace(/^minimumReleaseAgeExclude\s*:/, '').trim();
+    if (inline !== '' && !inline.startsWith('#')) return false;
+    let end = at;
+    for (let i = at + 1; i < lines.length; i += 1) {
+      const line = lines[i];
+      if (/^\s*$/.test(line) || /^\s*#/.test(line) || /^\s+-/.test(line)) {
+        end = i;
+        continue;
+      }
+      break;
+    }
+    for (let i = at + 1; i <= end; i += 1) {
+      const match = /^(\s*-\s*)(.*)$/.exec(lines[i]);
+      if (!match) continue;
+      const entry = parseExcludeEntry(match[2]);
+      if (entry === null || entry.name !== name) continue;
+      if (entry.versions.includes(version)) return true;
+      lines[i] = `${match[1]}${addVersionToEntry(match[2], version)}`;
+      fs.writeFileSync(file, lines.join('\n'));
+      return true;
+    }
+    let indent = '  ';
+    for (let i = at + 1; i <= end; i += 1) {
+      const match = /^(\s+)-/.exec(lines[i]);
+      if (match) {
+        indent = match[1];
+        break;
+      }
+    }
+    lines.splice(end + 1, 0, `${indent}- ${excludeScalar(name, version)}`);
+    fs.writeFileSync(file, lines.join('\n'));
+    return true;
+  }
+  const tail = text.replace(/\s*$/, '');
+  fs.writeFileSync(file, `${tail}${tail ? '\n' : ''}minimumReleaseAgeExclude:\n  - ${excludeScalar(name, version)}\n`);
+  return true;
+}
+
+/** 一条排除规则：包名 + 已列举的版本（拼在 ` || ` 后面）。看不懂就回 null，别猜。 */
+function parseExcludeEntry(raw) {
+  let body = String(raw || '').trim();
+  if (body === '' || body.startsWith('#')) return null;
+  const quote = /^(['"])(.*)\1\s*$/.exec(body);
+  if (quote) {
+    body = quote[2];
+  } else {
+    const hash = body.search(/\s#/);
+    if (hash !== -1) body = body.slice(0, hash).trim();
+  }
+  const parts = body.split('||').map(part => part.trim()).filter(Boolean);
+  if (parts.length === 0) return null;
+  const at = parts[0].lastIndexOf('@');
+  if (at <= 0) return null;
+  return {
+    name: parts[0].slice(0, at),
+    versions: parts.map(part => part.slice(part.lastIndexOf('@') + 1)),
+  };
+}
+
+/** 往一条规则后面追版本，引号与行尾注释原样保留。 */
+function addVersionToEntry(raw, version) {
+  const body = String(raw).trim();
+  const quote = /^(['"])(.*)\1\s*$/.exec(body);
+  if (quote) return `${quote[1]}${quote[2]} || ${version}${quote[1]}`;
+  const hash = body.search(/\s#/);
+  if (hash === -1) return `${body} || ${version}`;
+  return `${body.slice(0, hash)} || ${version}${body.slice(hash)}`;
+}
+
+/** 写进 YAML 的一条新规则；`@scope/...` 这种以 `@` 开头的标量必须带引号。 */
+function excludeScalar(name, version) {
+  const value = `${name}@${version}`;
+  return value.startsWith('@') ? `'${value}'` : value;
+}
+
+/**
+ * pnpm 说「记录的 store 和现在解析的不是同一个」时，把记录里的那个写回 profile。
+ *
+ * 这是 pnpm 报错里给的持久修法（`store-dir` 只在命令行那一次有效，改不改写
+ * `node_modules/.modules.yaml` 里的记录才是关键）。只加、不改：已经有 `storeDir` 就不动，
+ * 那种情况不是我们该替人翻的。
+ */
+function ensureProfileStoreDir(profileDir, storeDir) {
+  const file = path.join(profileDir, 'pnpm-workspace.yaml');
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return false;
+  }
+  if (/^storeDir\s*:/m.test(text)) return false;
+  const quoted = /[\s#:'"]/.test(storeDir) ? JSON.stringify(storeDir) : storeDir;
+  const tail = text.replace(/\s*$/, '');
+  fs.writeFileSync(file, `${tail}${tail ? '\n' : ''}storeDir: ${quoted}\n`);
+  return true;
+}
+
+/** `child` 是不是 `parent` 以内（用来确认报错里的 node_modules 真是这个 profile 的）。 */
+function isInsideDir(parent, child) {
+  const rel = path.relative(path.resolve(parent), path.resolve(child));
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+/**
+ * 宿主**发布出来的**包管理器调用方式（DSH 桌面版把它挂在 `profileContext.packageManager`
  * 上，形状 `{command, args, env?}`）。
  *
  * 为什么非得用它、而不是 PATH 上那个 pnpm：桌面版由 GUI 拉起时 PATH 很干净，而且**版本
@@ -243,18 +469,15 @@ function run(command, args, { cwd, env, timeoutMs, spawnImpl = spawn }) {
  * @param {object} options
  * @param {string} options.profileNodeModules profile 的 `node_modules` 目录
  * @param {string} options.version           要装的版本（注册表给的）
- * @param {boolean} [options.force]          true = 跳过「新发布先晾一会儿」的门槛
- * @param {boolean} [options.auto]           自动更新那一轮：同样跳过发布晾置期（见文件头）
  * @param {() => any} [options.beforeInstall] 真正跑包管理器**之前**调一次（外壳用它把正在跑的
  *   那一代复制进回退目录）。包管理器一跑就把旧的 store 目录清掉了，晚一步没得复制。
- * @returns {Promise<{installed, skipped, beforeVersion, installedVersion, source, command, output, failure}>}
+ * @returns {Promise<{installed, skipped, beforeVersion, installedVersion, source, command,
+ *   manager, healed, releaseAgeRecorded, output, failure}>}
  */
 async function installLatest({
   profileNodeModules,
   version,
   name = DEFAULT_NAME,
-  force = false,
-  auto = false,
   timeoutMs = INSTALL_TIMEOUT_MS,
   env = process.env,
   platform = process.platform,
@@ -333,41 +556,55 @@ async function installLatest({
   }
 
   const spec = `${name}@${version}`;
-  const releaseAgeFlag = '--config.minimum-release-age=0';
-  // `auto` 与 `force` 一样一开始就带上开关：自动更新要「一检测到就装」，不该先被那道策略挡回来
-  // 再重试一遍（多等一轮、日志里多一条失败）。
-  const skipReleaseAge = force || auto;
+  // 一律带上：自动更新是「一检测到就装」，手动点的那一下同样是「现在就要」，没理由先让这道
+  // 策略挡一次、再靠失败重试绕过来。命令行与环境变量各带一份，pnpm 12 只认后者（见 POLICY_ENV）。
+  const policyArgs = ['--config.auto-install-peers=false', '--config.minimum-release-age=0'];
   const args = picked.manager === 'pnpm'
-    ? ['add', spec, '--config.auto-install-peers=false', ...(skipReleaseAge ? [releaseAgeFlag] : [])]
+    ? ['add', spec, ...policyArgs]
     : ['install', spec, '--no-audit', '--no-fund'];
-  let command = [picked.manager, ...args].join(' ');
+  const command = [picked.manager, ...args].join(' ');
   onEvent({ phase: 'install-started', command, manager: picked.kind });
 
-  const spawnAdd = extra => run(picked.command, [...picked.prefix, ...args, ...extra], {
+  const runManager = (extraArgs, baseArgs = args) => run(picked.command, [...picked.prefix, ...baseArgs, ...extraArgs], {
     cwd: profileDir,
-    env: { ...childEnv, ...picked.env },
+    env: { ...childEnv, ...picked.env, ...(picked.manager === 'pnpm' ? POLICY_ENV : {}) },
     timeoutMs,
   });
-  let result = await spawnAdd([]);
+
+  let result = await runManager([]);
   let output = result.output;
   /**
-   * 撞上 pnpm 的「新发布先晾一会儿」策略：**带上开关重试一次**。
+   * 宿主环境对不上：不是这个包有问题，是这台机器的依赖树跟当前 pnpm 对不上 —— 不修的话，
+   * 之后每一次更新都会撞同一堵墙。修一次、重试一次；修不了就如实失败，下个 tick 再来。
    *
-   * 为什么非重试不可：那道策略查的是**整份 lockfile**，不是我们要装的这个包。这台机器上
-   * 实测过一次 —— 另一个插件（`billion-context@0.1.192`）刚发不久，整份 lockfile 就被判
-   * 「含未过期的条目」而拒绝，于是我们自己的更新整整一天都做不了，而原因跟我们这个包毫无
-   * 关系。市场那边对这种拒绝也是带开关重试一次（`RELEASE_AGE_OVERRIDE`）。
-   *
-   * 只在**第一次没带开关**、且失败信息确实是这类策略时才重试：别的失败（网络、权限、盘满）
-   * 重试一次只会把同一条错误再说一遍，还多花一次等待。
+   * 两种现场各有各的修法，判据都在 pnpm 自己的报错里：
+   *   ① 布局是两个大版本之前建的（PUBLIC_HOIST_PATTERN_DIFF / VIRTUAL_STORE_DIR_MAX_LENGTH_DIFF）
+   *      → 用现在这版 pnpm 重建依赖树；
+   *   ② 记录的 store 与它现在解析的不是同一个（UNEXPECTED_STORE）→ 把**记录里的那个**写回
+   *      profile 的 storeDir。只取报错点名、且确实存在于盘上的那个路径；记录本身就是旧盘 /
+   *      不存在的路径时不动 —— 那是另一种坏法，写回去只会换一种失败。
    */
-  const releaseAgeLike = /MINIMUM_RELEASE_AGE|minimumReleaseAge|minimum-release-age|release age/i;
-  const retried = !result.ok && picked.manager === 'pnpm' && !skipReleaseAge && releaseAgeLike.test(output);
-  if (retried) {
-    onEvent({ phase: 'release-age-retry' });
-    result = await spawnAdd([releaseAgeFlag]);
-    command = [picked.manager, ...args, releaseAgeFlag].join(' ');
-    output = `${output}\n--- 撞上 pnpm 的发布时长策略，带上 ${releaseAgeFlag} 重试一次 ---\n${result.output}`;
+  let healed = null;
+  if (!result.ok && picked.manager === 'pnpm') {
+    if (HOIST_DIFF.test(output)) {
+      const rebuild = await runManager([], ['install', '--no-frozen-lockfile', ...policyArgs]);
+      if (rebuild.ok) {
+        healed = 'rebuild';
+        result = await runManager([]);
+        output = `${output}\n--- node_modules 是旧版 pnpm 建的，已重建依赖树并重试 ---\n${result.output}`;
+      } else {
+        output = `${output}\n--- 试着重建依赖树，但也没成：${rebuild.output} ---`;
+      }
+    } else if (/ERR_PNPM_UNEXPECTED_STORE/.test(output)) {
+      const linked = /currently linked from the store at "([^"]+)"/.exec(output)?.[1];
+      const modules = /The dependencies at "([^"]+)"/.exec(output)?.[1];
+      if (linked && modules && isInsideDir(profileDir, modules) && fs.existsSync(linked)
+        && ensureProfileStoreDir(profileDir, linked)) {
+        healed = 'store';
+        result = await runManager([]);
+        output = `${output}\n--- pnpm 记录的 store 与本机解析的不一致，已把记录里的那个写回 storeDir 并重试 ---\n${result.output}`;
+      }
+    }
   }
   const after = installedVersion(profileNodeModules, name);
   if (!result.ok) {
@@ -379,7 +616,8 @@ async function installLatest({
       source: declaredSource(profileDir, name),
       command,
       manager: picked.kind,
-      retried,
+      healed,
+      releaseAgeRecorded: false,
       output,
       // 超时与「真的失败了」分开说：前者可以再试，后者多半要看输出。
       failure: {
@@ -390,6 +628,8 @@ async function installLatest({
   }
   // 退出码 0 不算数：**盘上版本真的变了**才算装上（市场那份代码吃过这个亏）。
   const changed = after !== null && after !== beforeVersion;
+  // 这一版是我们绕开晾置期装进去的，登记进排除清单，免得它反过来把别的安装挡 24 小时。
+  const releaseAgeRecorded = changed ? recordReleaseAgeExclusion(profileDir, name, after) : false;
   return {
     installed: changed,
     skipped: false,
@@ -398,7 +638,8 @@ async function installLatest({
     source: declaredSource(profileDir, name),
     command,
     manager: picked.kind,
-    retried,
+    healed,
+    releaseAgeRecorded,
     output,
     failure: changed
       ? null
@@ -427,9 +668,12 @@ async function installLatest({
  * 把它搬到插件自己这条路上来。判到有人跑就**不动盘**，如实报成「可再试」，下个 tick 再来。
  *
  * `force` 是**用户明说「我知道，装吧」**的那一挡（面板上那颗「强制更新」）：它同时跳过
- * 这道闸和「新发布先晾一会儿」的门槛，而且不管有没有新版都装一遍。`auto`（宿主那一轮自动
- * 更新）跳过同样的两道闸，只是仍然「没新版就不动盘」—— 2026-10-26 用户要求自动更新一检测到
- * 新版就立刻装，所以它不再等发布晾置期，见文件头。
+ * 这道闸，而且不管有没有新版都装一遍。`auto`（宿主那一轮自动更新）跳过同一道闸，只是仍然
+ * 「没新版就不动盘」。发布晾置期**不再是一个「哪一档才跳过」的问题**：装的时候一律跳过，
+ * 装完把这一版登记进排除清单（见文件头），所以手动、强制、自动三条路的安装条件是一致的。
+ *
+ * 「查」用的是这台机器上 pnpm / npm 真正在用的那个注册表（`profileRegistry`），不是写死的
+ * 官方源：镜像是通的、官方源连不上的机器，也要能自己发现新版。
  */
 async function installLatestIfNeeded(options = {}) {
   const { profileNodeModules, force = false, auto = false, name = DEFAULT_NAME, agents = null } = options;
@@ -451,7 +695,17 @@ async function installLatestIfNeeded(options = {}) {
       check: null,
     };
   }
-  const check = await checkForUpdate({ installedVersion: beforeVersion, source });
+  // 查与装用同一个源：问一次这台机器上 pnpm / npm 真正在用的注册表（问不到才退回官方源）。
+  // 不这样做的话，镜像 / 私有源机器上会出现「检查更新说连不上、手动装却是通的」。
+  const registry = await profileRegistry({
+    profileNodeModules,
+    packageManager: options.packageManager ?? null,
+    env: options.env,
+    platform: options.platform,
+    dirs: options.dirs ?? null,
+    cache: options.registryCache,
+  });
+  const check = await checkForUpdate({ installedVersion: beforeVersion, source, base: registry ?? undefined });
   // 「有没有新版」排在「有没有人在跑」**前面**：没东西可装的时候，拿一句「有对话在跑」挡住
   // 真正的答案（已经是最新）是误导。
   if (!force && !check.updateAvailable) {
@@ -504,6 +758,10 @@ module.exports = {
   resolveExecutable,
   normalizeInvocation,
   runningAgentIds,
+  profileRegistry,
+  recordReleaseAgeExclusion,
+  ensureProfileStoreDir,
+  parseRegistryOutput,
   DEFAULT_NAME,
   INSTALL_TIMEOUT_MS,
   OUTPUT_TAIL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (dsh 0.2.x, peers resolved by the host)",
   "license": "MIT",
   "engines": {