@aaayeaaa-p1ws/dsh-plugin-auto-update 0.0.0-stage → 1.1.0

package/index.js

@@ -0,0 +1,1135 @@
+/**
+ * 插件自动更新（Host 侧）。
+ *
+ * 每次打开 DSH（宿主启动）后，等市场把自己那条路由挂好，就通过插件市场自己的
+ * 公开接口 UPDATE-API V1 检查已安装插件有没有新版本，有就一个接一个直接装。
+ *
+ * 为什么走 HTTP 接口而不是 import 市场的内部模块：
+ *   市场把 /dsh-market/api/v1/* 声明成「稳定契约」（lib/update-api-v1.js + UPDATE-API-V1.md），
+ *   内部函数则随时会变。宿主 → loopback 调自己的 webServer 是市场本来就支持的用法。
+ *
+ * 安全约束（宿主启动是 all-or-nothing，本文件的任何异常都不能往上抛）：
+ *   - 顶层只 import node 内置模块；
+ *   - apply() 里全部 try/catch，定时器 unref，dispose 时清干净；
+ *   - 只在 loopback 上请求，不改 profile 文件、不碰 pnpm、不做任何除了「调市场接口」以外的事。
+ *
+ * 节奏（2026-11-01 修）：
+ *   - 每次宿主启动都会检查一轮，这是用户要的「每天打开 DSH 就检查」。启动这一轮
+ *     不受「今天已经跑过」的限制，只做一次「距上次检查不足 bootMinIntervalMinutes
+ *     就跳过」的节流，避免一天里反复重启把检查打爆。
+ *   - 进程内的 tick 仍然按本地日历日判断，兼容「DSH 一直开着跨天」；
+ *     跨过午夜那一次算当天额度，但它不再是唯一机会 —— 下次开机还会再查。
+ *   - 新发布的版本要过 pnpm 的 minimumReleaseAge（默认 24h）才会被市场报出来，
+ *     所以「发布当天就装上」是不可能的，通常晚 1 天。
+ * 踩过的坑：v1 的 summary 只回 updateAvailable===true 的行，被等待期扣住的版本
+ * 直接不出现（heldUpdate 只存在于内部接口），所以查完显示「已是最新」是正常的。
+ */
+import { randomUUID } from 'node:crypto';
+import { appendFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { CONFIG_DEFAULTS, normalizeConfig, readConfigFile, tickDue, writeConfigFile } from './lib/store.mjs';
+import { desktopLaunchInfo, scheduleDesktopRestart } from './lib/restart.mjs';
+
+export const name = 'dsh-auto-update';
+
+/** 必须是显式依赖：拿 tools 服务要靠注入，apply 里再 ctx.get('tools') 是拿不到的。 */
+export const inject = ['tools', 'webServer'];
+
+const SCHEMA = 'dsh-market/update-api/v1';
+const TERMINAL = new Set(['succeeded', 'failed', 'cancelled', 'rolled-back']);
+
+/** 可配置项与默认值。市场那一侧同一时刻只允许一个更新操作，这里全部串行。 */
+const DEFAULTS = {
+  enabled: true,
+  autoApply: true,
+  oncePerDay: true,
+  delaySeconds: 12, // 启动后等多久再动手：让宿主把路由挂完、市场跑完自己的恢复逻辑
+  bootMinIntervalMinutes: 20, // 距上次检查不到这么久就跳过一次启动检查（防止一天里反复重启时狂打市场）
+  tickMinutes: 5, // 复查「是不是新的一天 / 有没有欠着的更新」，没欠账时只是一次读数
+  agentsBusyRetryMinutes: 5, // 有 agent 正在跑时市场会拒绝更新（AGENTS_RUNNING），隔几分钟再来，不算失败
+  drainWaitMinutes: 10, // 改用市场的 drain 模式后，最多陪它等 agent 空闲这么久；超时就把操作留给市场自己完成
+  heldRetryMinutes: 120, // 版本还在 24h 等待期（held）：隔两小时再看一眼，别把今天的额度用掉
+  requestTimeoutMs: 25000,
+  operationTimeoutMs: 180000, // 单个插件（含 pnpm 安装）最多等多久
+  pollIntervalMs: 1500,
+  runBudgetMs: 15 * 60 * 1000,
+  retryDelayMinutes: 30,
+  maxAttemptsPerDay: 5, // 现在是「自上次成功以来连续失败了几轮」的上限，成功后归零
+  historyLimit: 20,
+};
+
+const EMPTY_STATE = {
+  version: 1,
+  lastDay: null,
+  lastCheckAt: null,
+  lastResult: null,
+  skipUntil: null,
+  attempts: { day: null, count: 0 },
+  agentsBusyStreak: 0,
+  pendingRefresh: [],
+  history: [],
+  /** 上次弹窗确认过的日期（当天弹过就不再弹） */
+  popupAckDay: null,
+  /** 待展示的一轮结果：{ day, at, result } */
+  popupPending: null,
+};
+
+// ---------------------------------------------------------------- 小工具
+
+function errText(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    if (typeof timer.unref === 'function') timer.unref();
+  });
+}
+
+function localDay(date = new Date()) {
+  const d = date instanceof Date ? date : new Date(date);
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+function localTime(value) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (!(date instanceof Date) || Number.isNaN(date.getTime())) return typeof value === 'string' ? value : '?';
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+function num(value, fallback, min, max) {
+  const n = typeof value === 'number' ? value : Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  if (n < min) return min;
+  if (n > max) return max;
+  return n;
+}
+
+function bool(value, fallback) {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+function str(value, fallback) {
+  return typeof value === 'string' && value.trim() !== '' ? value.trim() : fallback;
+}
+
+function clip(value, max = 600) {
+  const text = typeof value === 'string' ? value : value === undefined || value === null ? '' : String(value);
+  return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+
+function trimBase(value) {
+  if (typeof value !== 'string') return null;
+  const text = value.trim().replace(/\/+$/, '');
+  return /^https?:\/\/[^\s]+$/i.test(text) ? text : null;
+}
+
+/** 一次 HTTP 往返；任何异常都收敛成 {status:0, error}，调用方不用再 try。 */
+async function requestJson(base, path, options = {}) {
+  const timeoutMs = options.timeoutMs || 25000;
+  const url = `${base}${path}`;
+  const init = {
+    method: options.method || 'GET',
+    headers: { accept: 'application/json' },
+    signal: AbortSignal.timeout(timeoutMs),
+  };
+  if (options.body !== undefined) {
+    init.headers['content-type'] = 'application/json';
+    init.body = JSON.stringify(options.body);
+  }
+  try {
+    const response = await fetch(url, init);
+    const text = await response.text();
+    let json = null;
+    try {
+      json = text ? JSON.parse(text) : null;
+    } catch {
+      json = null;
+    }
+    return { status: response.status, ok: response.ok, json, text: clip(text, 1200) };
+  } catch (error) {
+    return { status: 0, ok: false, json: null, text: clip(errText(error), 400) };
+  }
+}
+
+function messageOf(reply) {
+  const json = reply && reply.json;
+  if (json && typeof json === 'object') {
+    if (typeof json.error === 'string') return clip(json.error, 600);
+    if (json.failure && typeof json.failure.message === 'string') return clip(json.failure.message, 600);
+  }
+  return clip((reply && reply.text) || '');
+}
+
+function codeOf(reply) {
+  const json = reply && reply.json;
+  if (json && typeof json === 'object') {
+    if (json.failure && typeof json.failure.code === 'string') return json.failure.code;
+    if (typeof json.error === 'string' && json.error) return 'HTTP_' + String(reply.status);
+  }
+  return 'HTTP_' + String((reply && reply.status) || 0);
+}
+
+/**
+ * 这些状态码只说明「这一轮不行」，不代表今天没戏：
+ * 0 是网络/端口失败，405 见过市场路由热挂载瞬间的空回（2026-11-10 的坑），
+ * 409 是市场被别的操作占着（同一时刻只允许一个更新），5xx 是市场自己出状况。
+ */
+function isTransientStatus(status) {
+  return status === 0 || status === 405 || status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
+}
+
+/**
+ * 市场的「版本还在等待期」拒绝（pnpm minimumReleaseAge，发布不满 24h）：
+ * 不是故障也不是今天没戏，等它的时间窗过去再试就行。drain 路径下市场只回
+ * UPDATE_REJECTED + 原文错误，所以除了 code 还要看文案。
+ */
+function isHeldUpdate(outcome) {
+  if (!outcome) return false;
+  const code = String(outcome.code || '');
+  if (code === 'RELEASE_AGE_HELD' || code === 'RELEASE_AGE_UNVERIFIED' || code === 'TARGET_CHANGED') return true;
+  return /等待期|held|release-age/i.test(String(outcome.message || ''));
+}
+
+// ---------------------------------------------------------------- 插件入口
+
+export function apply(ctx, rawConfig = {}) {
+  const config = rawConfig && typeof rawConfig === 'object' ? rawConfig : {};
+  const cfg = {
+    enabled: bool(config.enabled, DEFAULTS.enabled),
+    autoApply: bool(config.autoApply, DEFAULTS.autoApply),
+    oncePerDay: bool(config.oncePerDay, DEFAULTS.oncePerDay),
+    delaySeconds: num(config.delaySeconds, DEFAULTS.delaySeconds, 0, 600),
+    bootMinIntervalMinutes: num(config.bootMinIntervalMinutes, DEFAULTS.bootMinIntervalMinutes, 0, 1440),
+    tickMinutes: num(config.tickMinutes, DEFAULTS.tickMinutes, 1, 1440),
+    agentsBusyRetryMinutes: num(config.agentsBusyRetryMinutes, DEFAULTS.agentsBusyRetryMinutes, 1, 120),
+    drainWaitMinutes: num(config.drainWaitMinutes, DEFAULTS.drainWaitMinutes, 0, 120),
+    heldRetryMinutes: num(config.heldRetryMinutes, DEFAULTS.heldRetryMinutes, 5, 1440),
+    requestTimeoutMs: num(config.requestTimeoutMs, DEFAULTS.requestTimeoutMs, 2000, 120000),
+    operationTimeoutMs: num(config.operationTimeoutMs, DEFAULTS.operationTimeoutMs, 30000, 1800000),
+    pollIntervalMs: num(config.pollIntervalMs, DEFAULTS.pollIntervalMs, 500, 30000),
+    runBudgetMs: num(config.runBudgetMs, DEFAULTS.runBudgetMs, 60000, 3600000),
+    retryDelayMinutes: num(config.retryDelayMinutes, DEFAULTS.retryDelayMinutes, 1, 720),
+    maxAttemptsPerDay: num(config.maxAttemptsPerDay, DEFAULTS.maxAttemptsPerDay, 1, 100),
+    historyLimit: num(config.historyLimit, DEFAULTS.historyLimit, 1, 200),
+  };
+
+  const home = process.env.DSH_HOME && process.env.DSH_HOME.trim() !== '' ? process.env.DSH_HOME.trim() : join(homedir(), '.dsh');
+  const stateDir = join(home, 'auto-update');
+  const statePath = join(stateDir, 'state.json');
+  const logPath = join(stateDir, 'log.ndjson');
+  /** GUI 里改得到的设置：config.json 覆盖 cordis.patch.yml 里的同名项。 */
+  const configPath = join(stateDir, 'config.json');
+
+  let disposed = false;
+  let running = false;
+  const handles = new Set();
+  // 每次装载（= 一个宿主进程）一个新的 id，用来判断「上次写的待重启提示是不是重启前的」。
+  const instanceId = randomUUID();
+
+  // ------------------------------------------------------------ 落盘
+
+  async function readState() {
+    try {
+      const text = await readFile(statePath, 'utf8');
+      const parsed = JSON.parse(text);
+      if (!parsed || typeof parsed !== 'object') return { ...EMPTY_STATE };
+      return {
+        ...EMPTY_STATE,
+        ...parsed,
+        attempts:
+          parsed.attempts && typeof parsed.attempts === 'object'
+            ? { day: parsed.attempts.day ?? null, count: Number(parsed.attempts.count) || 0 }
+            : { ...EMPTY_STATE.attempts },
+        pendingRefresh: Array.isArray(parsed.pendingRefresh) ? parsed.pendingRefresh : [],
+        history: Array.isArray(parsed.history) ? parsed.history : [],
+        popupAckDay: typeof parsed.popupAckDay === 'string' ? parsed.popupAckDay : null,
+        popupPending:
+          parsed.popupPending && typeof parsed.popupPending === 'object' && parsed.popupPending.result
+            ? parsed.popupPending
+            : null,
+      };
+    } catch {
+      return { ...EMPTY_STATE, attempts: { ...EMPTY_STATE.attempts }, pendingRefresh: [], history: [] };
+    }
+  }
+
+  async function writeState(state) {
+    try {
+      await mkdir(stateDir, { recursive: true });
+      const tmp = `${statePath}.tmp`;
+      await writeFile(tmp, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+      await rename(tmp, statePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function logLine(level, event, message, extra) {
+    const entry = { at: new Date().toISOString(), level, event, message: clip(message, 1200) };
+    if (extra && typeof extra === 'object') entry.data = extra;
+    try {
+      await mkdir(stateDir, { recursive: true });
+      await appendFile(logPath, `${JSON.stringify(entry)}\n`, 'utf8');
+    } catch {
+      /* 日志写不进去也不影响主流程 */
+    }
+  }
+
+  // ------------------------------------------------------------ 用户设置
+
+  let userConfig = null;
+  let userConfigLoaded = false;
+
+  async function currentConfig() {
+    if (!userConfigLoaded) {
+      userConfigLoaded = true;
+      userConfig = (await readConfigFile(configPath)) || normalizeConfig({}, CONFIG_DEFAULTS);
+    }
+    return userConfig;
+  }
+
+  async function saveConfig(patch) {
+    const base = await currentConfig();
+    const merged = normalizeConfig({ ...base, ...(patch && typeof patch === 'object' ? patch : {}) }, CONFIG_DEFAULTS);
+    const saved = await writeConfigFile(configPath, merged);
+    if (saved) userConfig = saved;
+    await logLine('info', 'config-saved', `设置已保存：${JSON.stringify(saved || merged)}`);
+    return saved || merged;
+  }
+
+  /** 弹窗只需要「装了什么 / 挂在哪」，把一轮结果裁小再存。 */
+  function popupPayload(result) {
+    const applied = (result.applied || []).map((item) => ({
+      name: item.name,
+      from: item.from || null,
+      to: item.installed || item.to || null,
+    }));
+    const failed = (result.failed || []).map((item) => ({
+      name: item.name,
+      reason: item.message || item.code || item.state || '未知原因',
+      code: item.code || item.state || null,
+      inUse: item.inUse === true,
+    }));
+    return {
+      at: result.at,
+      day: result.day,
+      checked: result.checked,
+      updatable: result.updatable,
+      applied,
+      failed,
+      deferred: (result.deferred || []).map((item) => ({ name: item.name, reason: item.reason || null })),
+      note: result.note || null,
+    };
+  }
+
+  // ------------------------------------------------------------ 找市场接口
+
+  /**
+   * 解析出本机市场 API 的 origin。
+   * 优先问宿主自己的 webServer（最准），再退到环境变量，最后试默认端口。
+   * 逐个探 capabilities，只有真的答 200 的才算数。
+   */
+  async function resolveMarket() {
+    const candidates = [];
+    const push = (value) => {
+      const base = trimBase(value);
+      if (base && !candidates.includes(base)) candidates.push(base);
+    };
+    try {
+      const server = (ctx.get && ctx.get('webServer')) || ctx.webServer;
+      if (server && typeof server.getOrigin === 'function') push(server.getOrigin());
+    } catch {
+      /* 拿不到就走后面的候选 */
+    }
+    push(process.env.DSH_WEB_URL);
+    push('http://127.0.0.1:8817');
+    push('http://localhost:8817');
+
+    for (const base of candidates) {
+      const reply = await requestJson(base, '/dsh-market/api/v1/capabilities', { timeoutMs: cfg.requestTimeoutMs });
+      if (reply.status === 200 && reply.json && reply.json.schema === SCHEMA) {
+        return { base, capabilities: reply.json, tried: candidates };
+      }
+      if (reply.status === 404) {
+        // 端口通但没挂市场路由：市场没装或还没挂完，换下一个候选没意义，直接说明原因。
+        throw new Error(`市场接口不在 ${base}（HTTP 404）：dshmarket 可能未安装或尚未就绪`);
+      }
+    }
+    throw new Error(`找不到可用的市场接口，已尝试：${candidates.join(', ') || '（无候选）'}`);
+  }
+
+  // ------------------------------------------------------------ 更新流程
+
+  /** 发起一次更新。drain 模式让市场先排队，等 agent 空闲了它自己装（不占用我们的轮次）。 */
+  function postUpdate(base, name, drain) {
+    const body = drain ? { packageName: name, busyPolicy: 'drain' } : { packageName: name };
+    return requestJson(base, '/dsh-market/api/v1/updates', { method: 'POST', body, timeoutMs: cfg.requestTimeoutMs });
+  }
+
+  async function updateOne(base, pkg, deadline) {
+    const name = str(pkg && pkg.name, '');
+    const from = str(pkg && pkg.installedVersion, null);
+    const to = str(pkg && pkg.latestVersion, null);
+    const base_ = { name, from, to, source: str(pkg && pkg.source, null) };
+    if (!name) return { ...base_, state: 'failed', code: 'BAD_PACKAGE', message: '市场返回的插件没有名字' };
+
+    // agent 正在跑的时候普通更新会被市场直接拒（AGENTS_RUNNING）。drain 模式让市场先排上队，
+    // 等 agent 空闲了它自己装完 —— 这样「一边聊天一边开着 DSH」也能把更新补上（2026-11-10 的坑）。
+    let start = await postUpdate(base, name, true);
+    if (start.status === 400 && /AGENT_DRAIN_UNSUPPORTED/.test(String(codeOf(start)))) {
+      // 宿主没有 Agent 维护边界、不支持 drain：退回普通的直连更新。
+      start = await postUpdate(base, name, false);
+    }
+    if (start.status !== 202) {
+      const code = codeOf(start);
+      const message = messageOf(start);
+      const transient = isTransientStatus(start.status) || code === 'OPERATION_BUSY';
+      return {
+        ...base_,
+        state: 'failed',
+        code,
+        message,
+        // 405 / 409 / 5xx / 网络失败都只是「这一轮不行」；只有 400/404 这种才是真的没戏。
+        retryable: transient,
+        held: isHeldUpdate({ code, message }),
+      };
+    }
+    const operationId = str(start.json && start.json.operation && start.json.operation.operationId, '');
+    if (!operationId) return { ...base_, state: 'failed', code: 'NO_OPERATION', message: '市场没有返回 operationId' };
+
+    const stopAt = Math.min(Date.now() + cfg.operationTimeoutMs, deadline);
+    const waitCap = Date.now() + cfg.drainWaitMinutes * 60000;
+    while (Date.now() < stopAt && !disposed) {
+      await sleep(cfg.pollIntervalMs);
+      const reply = await requestJson(
+        base,
+        `/dsh-market/api/v1/operations?operationId=${encodeURIComponent(operationId)}`,
+        { timeoutMs: cfg.requestTimeoutMs },
+      );
+      if (reply.status !== 200) continue;
+      const operation = (reply.json && reply.json.operation) || {};
+      const state = str(operation.state, '');
+      // drain：市场在等 agent 空闲（operation.wait 非空）。这种情况可能等很久，
+      // 别陪着干等到 operationTimeoutMs —— 记一笔交给下一轮，市场自己会装完。
+      if (operation.wait && Date.now() > waitCap) {
+        return {
+          ...base_,
+          state: 'deferred',
+          operationId,
+          code: 'DRAIN_WAITING',
+          message: `市场排上队了，等 agent 空闲（${str(operation.wait.reason, 'agents')}）就会自己装`,
+          retryable: true,
+          drainPending: true,
+        };
+      }
+      if (!TERMINAL.has(state)) continue;
+      const failure = operation.failure && typeof operation.failure === 'object' ? operation.failure : null;
+      const outcome = operation.outcome && typeof operation.outcome === 'object' ? operation.outcome : {};
+      return {
+        ...base_,
+        state,
+        operationId,
+        installed: str(operation.installedVersion, to),
+        code: failure ? str(failure.code, null) : null,
+        message: failure ? clip(failure.message, 600) : null,
+        retryable: failure ? failure.retryable === true : false,
+        refreshRequired: outcome.refreshRequired === true,
+        restartRequired: outcome.restartRequired === true,
+      };
+    }
+    return {
+      ...base_,
+      state: 'failed',
+      operationId,
+      code: 'CLIENT_TIMEOUT',
+      message: `等了 ${Math.round(cfg.operationTimeoutMs / 1000)} 秒还没结束（可能是网络慢，也可能市场在等别的东西）`,
+      retryable: true,
+    };
+  }
+
+  /** 市场同一时刻只允许一个操作，所以严格串行；市场自己排最后，免得它一升级就把接口换掉。 */
+  async function applyAll(base, packages, result) {
+    const ordered = [...packages].sort((a, b) => weight(a) - weight(b));
+    const deadline = Date.now() + cfg.runBudgetMs;
+    for (const pkg of ordered) {
+      if (disposed) break;
+      if (Date.now() > deadline) {
+        result.skipped.push({ name: str(pkg && pkg.name, '?'), reason: '本次总时长用完，留到下次' });
+        continue;
+      }
+      const name = str(pkg && pkg.name, '');
+      try {
+        const outcome = await updateOne(base, pkg, deadline);
+        if (outcome.state === 'succeeded') {
+          result.applied.push(outcome);
+          await logLine('info', 'updated', `${outcome.name}: ${outcome.from || '?'} → ${outcome.installed || outcome.to || '?'}`);
+          if (outcome.restartRequired || outcome.refreshRequired) {
+            if (!result.pendingRefresh.includes(outcome.name)) result.pendingRefresh.push(outcome.name);
+          }
+          continue;
+        }
+        if (outcome.state === 'deferred' || outcome.drainPending === true) {
+          // 市场已经排上队了（drain），它会在 agent 空闲时自己装完；这一轮不再占用市场那唯一的坑。
+          const index = ordered.indexOf(pkg);
+          result.deferred.push({ ...outcome, reason: outcome.message || '市场排队中，稍后自己装完' });
+          for (const rest of ordered.slice(index + 1)) {
+            result.deferred.push({
+              name: str(rest && rest.name, '?'),
+              state: 'deferred',
+              code: 'DRAIN_WAITING',
+              reason: '市场同一时刻只处理一个操作，等前一个排完',
+            });
+          }
+          await logLine('info', 'update-deferred', `${outcome.name}: ${outcome.message || '市场排队中'}`);
+          break;
+        }
+        if (outcome.code === 'AGENTS_RUNNING') {
+          // 市场在 agent 跑着的时候一律拒绝更新；剩下几个也一定一样，直接收手，等空闲再来。
+          const index = ordered.indexOf(pkg);
+          result.deferred.push({ ...outcome, reason: 'agent 正在运行，稍后自动重试' });
+          for (const rest of ordered.slice(index + 1)) {
+            result.deferred.push({
+              name: str(rest && rest.name, '?'),
+              state: 'deferred',
+              code: 'AGENTS_RUNNING',
+              reason: 'agent 正在运行，稍后自动重试',
+            });
+          }
+          await logLine('info', 'update-deferred', `${outcome.name}: agent 正在运行，本轮先不动手`);
+          break;
+        }
+        result.failed.push({
+          ...outcome,
+          // 「插件正在使用中」是唯一一种用户点一下就能救回来的失败：关掉插件 → 更新 → 重启。
+          inUse: /bundle-in-use|正在使用中|the plugin is in use/i.test(String(outcome.message || outcome.code || '')),
+        });
+        await logLine(
+          'warn',
+          outcome.held ? 'update-held' : 'update-failed',
+          `${outcome.name}: ${outcome.code || outcome.state} — ${outcome.message || ''}`,
+        );
+      } catch (error) {
+        const message = errText(error);
+        result.failed.push({ name, state: 'failed', code: 'EXCEPTION', message: clip(message, 600), retryable: true });
+        await logLine('error', 'update-exception', `${name}: ${message}`);
+      }
+    }
+  }
+
+  function weight(pkg) {
+    const name = str(pkg && pkg.name, '').toLowerCase();
+    return name === 'dshmarket' || name === '@deepseek-ai/dsh-market' ? 9 : 0;
+  }
+
+  // ------------------------------------------------------------ 每日判定 + 执行
+
+  async function runOnce(reason, options = {}) {
+    const state = await readState();
+    const now = Date.now();
+    const today = localDay();
+    const conf = await currentConfig();
+
+    const forced = options.force === true;
+    if (!forced && conf.enabled === false) {
+      return { ok: true, skipped: '自动更新已在设置里关掉', state };
+    }
+
+    // 退避只挡进程内的 tick；开机这一轮靠下面的 bootMinIntervalMinutes 节流，不再被上一次的退避压住
+    // （否则「上次失败 → 30 分钟不再查」会把用户开机时想要的那次检查也吃掉）。
+    if (!forced && state.skipUntil && reason !== 'boot') {
+      const until = Date.parse(state.skipUntil);
+      if (Number.isFinite(until) && until > now) {
+        return { ok: true, skipped: `退避中，${localTime(state.skipUntil)} 之后再试`, state };
+      }
+    }
+
+    if (!forced && reason === 'boot') {
+      // 启动这一轮就是用户要的「每天打开 DSH 就检查」：不看 lastDay，只看「刚刚查过没有」。
+      // 少了这道判断，跨午夜那次 tick 会把当天额度用掉，之后所有开机检查都被跳过（2026-11-01 的坑）。
+      const last = Date.parse(state.lastCheckAt || '');
+      const gapMinutes = cfg.bootMinIntervalMinutes;
+      if (Number.isFinite(last) && gapMinutes > 0 && now - last < gapMinutes * 60000) {
+        const skipped = `距上次检查不到 ${gapMinutes} 分钟（上次 ${localTime(state.lastCheckAt)}）`;
+        await logLine('info', 'boot-skip', skipped);
+        return { ok: true, skipped, state };
+      }
+      // 定时 / 间隔模式下，开机太早（还没到点）就不算这一轮，交给 tick 到点再跑。
+      if (conf.mode !== 'startup' && !state.skipUntil) {
+        const due = tickDue(conf, state);
+        if (!due.due && state.lastDay === today) return { ok: true, skipped: due.why, state };
+      }
+    } else if (!forced) {
+      if (conf.mode === 'startup') {
+        // 进程内 tick：当天已经成功跑过就不再重复；跨天时 lastDay 是昨天，自然放行。
+        // skipUntil 有值 = 还欠着一轮重试（agent 占着、或上次重试类失败），这种情况不能被日期闸门挡掉。
+        if (cfg.oncePerDay && state.lastDay === today && !state.skipUntil) {
+          return { ok: true, skipped: `今天（${today}）已经检查过`, state };
+        }
+      } else if (!state.skipUntil) {
+        const due = tickDue(conf, state);
+        if (!due.due) return { ok: true, skipped: due.why, state };
+      }
+    }
+
+    const attempts = state.attempts && state.attempts.day === today ? state.attempts : { day: today, count: 0 };
+    if (!forced && attempts.count >= cfg.maxAttemptsPerDay) {
+      return { ok: false, skipped: `连续失败 ${attempts.count} 次，不再自动重试`, state };
+    }
+
+    const result = {
+      at: new Date().toISOString(),
+      day: today,
+      reason,
+      base: null,
+      marketVersion: null,
+      checked: 0,
+      updatable: 0,
+      applied: [],
+      failed: [],
+      deferred: [],
+      skipped: [],
+      pendingRefresh: [],
+      note: null,
+    };
+
+    // 先记一次尝试再动手：万一中途崩了，也不会陷入当天无限重试。
+    attempts.count += 1;
+    state.attempts = attempts;
+    state.lastCheckAt = result.at;
+    await writeState(state);
+
+    let fatal = null;
+    try {
+      const market = await resolveMarket();
+      result.base = market.base;
+      result.marketVersion = str(market.capabilities && market.capabilities.marketVersion, null);
+
+      const summary = await requestJson(market.base, '/dsh-market/api/v1/updates/summary?force=1', {
+        timeoutMs: Math.max(cfg.requestTimeoutMs, 60000), // 全量检查要问 npm / GitHub，慢一点
+      });
+      if (summary.status !== 200 || !summary.json || typeof summary.json !== 'object') {
+        throw new Error(`检查更新失败：HTTP ${summary.status} ${messageOf(summary)}`.trim());
+      }
+      result.checked = Number(summary.json.checked) || 0;
+      const packages = Array.isArray(summary.json.packages) ? summary.json.packages : [];
+      result.updatable = packages.length;
+
+      if (packages.length === 0) {
+        result.note = `已是最新（检查了 ${result.checked} 个插件）`;
+      } else if (!conf.autoApply) {
+        result.note = `发现 ${packages.length} 个可更新，但「只检查不安装」开着，只记录`;
+        result.skipped.push(...packages.map((pkg) => ({ name: str(pkg && pkg.name, '?'), reason: 'autoApply=false' })));
+      } else {
+        result.note = `发现 ${packages.length} 个可更新，开始安装`;
+        await applyAll(market.base, packages, result);
+      }
+    } catch (error) {
+      fatal = errText(error);
+      result.note = fatal;
+      await logLine('error', 'check-failed', fatal);
+    }
+
+    const retryable = result.failed.some((item) => item.retryable === true);
+    const busy = result.failed.some((item) => item.code === 'OPERATION_BUSY');
+    const held = result.failed.some((item) => item.held === true);
+    const deferredOnly = result.deferred.length > 0 && result.failed.length === 0;
+    const allDone = fatal === null && result.failed.length === 0 && result.deferred.length === 0;
+    const next = await readState();
+    // 换了进程（真的重启过），上一轮的「需重启生效」提示就过期了。
+    if (next.instanceId !== instanceId) {
+      next.pendingRefresh = [];
+      next.instanceId = instanceId;
+    }
+    next.lastCheckAt = result.at;
+    next.lastResult = result;
+    next.attempts = attempts;
+    if (result.pendingRefresh.length > 0) {
+      const merged = new Set([...(Array.isArray(next.pendingRefresh) ? next.pendingRefresh : []), ...result.pendingRefresh]);
+      next.pendingRefresh = [...merged];
+    }
+    if (allDone) {
+      next.lastDay = today;
+      next.skipUntil = null;
+      next.agentsBusyStreak = 0;
+      next.heldRounds = 0;
+      // 成功一轮就把「连续失败」清零：attempts 现在只统计失败，不再按天累计，
+      // 否则一天里开几次 DSH 就会撞上 maxAttemptsPerDay 而再也不查。
+      next.attempts = { day: today, count: 0 };
+    } else if (deferredOnly) {
+      // agent 正忙、市场主动拒绝：这不算今天的额度，隔几分钟再来；连着被拒就指数退避，别一直打搅。
+      attempts.count = Math.max(0, attempts.count - 1);
+      const streak = (Number(next.agentsBusyStreak) || 0) + 1;
+      next.agentsBusyStreak = streak;
+      const minutes = Math.min(cfg.agentsBusyRetryMinutes * 2 ** Math.min(streak - 1, 4), 60);
+      next.skipUntil = new Date(Date.now() + minutes * 60000).toISOString();
+    } else if (held && !retryable && fatal === null) {
+      // 只是「版本太新、还在 24h 等待期」：不是故障，也不是今天没戏 —— 过两小时再看一眼。
+      // 以前这种被当成「不可重试」，直接把 lastDay 记成今天、一整天都不再检查了（2026-11-10 的坑）。
+      attempts.count = Math.max(0, attempts.count - 1);
+      const heldRounds = (Number(next.heldRounds) || 0) + 1;
+      next.heldRounds = heldRounds;
+      if (heldRounds > 6) {
+        // 连着几轮都卡在等待期：今天先算了，明天照常检查。
+        next.lastDay = today;
+        next.skipUntil = null;
+        next.heldRounds = 0;
+      } else {
+        next.skipUntil = new Date(Date.now() + cfg.heldRetryMinutes * 60000).toISOString();
+      }
+    } else if (retryable || fatal !== null) {
+      // 市场被别的操作占着 / 网络抽风：几分钟就回来；别的失败按 retryDelayMinutes 退。
+      const minutes = busy ? cfg.agentsBusyRetryMinutes : cfg.retryDelayMinutes;
+      next.skipUntil = new Date(Date.now() + minutes * 60000).toISOString();
+    } else {
+      // 有非重试类失败（比如市场自己不能自己更新）：当天不再折腾，明天再试。
+      next.lastDay = today;
+      next.skipUntil = null;
+    }
+    const history = Array.isArray(next.history) ? next.history : [];
+    history.unshift({
+      at: result.at,
+      day: today,
+      reason,
+      checked: result.checked,
+      updatable: result.updatable,
+      applied: result.applied.map((item) => `${item.name} ${item.from || '?'}→${item.installed || item.to || '?'}`),
+      failed: result.failed.map((item) => `${item.name} ${item.code || ''}`.trim()),
+      deferred: result.deferred.map((item) => item.name),
+      note: result.note,
+    });
+    next.history = history.slice(0, cfg.historyLimit);
+    // 这一轮真的装过东西或失败过，才值得开机弹一次；全是最新就别打扰。
+    const interesting = result.applied.length + result.failed.length > 0;
+    if (conf.popupEnabled !== false && interesting) {
+      next.popupPending = { day: today, at: result.at, result: popupPayload(result) };
+    }
+    await writeState(next);
+
+    await logLine('info', 'checked', result.note || '', {
+      checked: result.checked,
+      updatable: result.updatable,
+      applied: result.applied.length,
+      failed: result.failed.length,
+    });
+
+    return { ok: fatal === null, result, state: next, fatal };
+  }
+
+  async function tick(reason, options = {}) {
+    if (disposed) return { ok: false, skipped: '插件已卸载' };
+    if (running) return { ok: false, skipped: '上一轮还没跑完' };
+    running = true;
+    try {
+      return await runOnce(reason, options);
+    } catch (error) {
+      await logLine('error', 'tick', errText(error));
+      return { ok: false, error: errText(error) };
+    } finally {
+      running = false;
+    }
+  }
+
+  // ------------------------------------------------------------ 定时器
+
+  function scheduleTimeout(fn, delay) {
+    const timer = setTimeout(() => {
+      handles.delete(timer);
+      try {
+        fn();
+      } catch {
+        /* 定时器里绝不抛 */
+      }
+    }, delay);
+    if (typeof timer.unref === 'function') timer.unref();
+    handles.add(timer);
+    return timer;
+  }
+
+  function clearAll() {
+    for (const handle of handles) {
+      try {
+        clearTimeout(handle);
+        clearInterval(handle);
+      } catch {
+        /* ignore */
+      }
+    }
+    handles.clear();
+  }
+
+  try {
+    ctx.effect(() => () => {
+      disposed = true;
+      clearAll();
+    });
+  } catch {
+    /* 没有 effect 就靠进程退出兜底 */
+  }
+
+  if (!cfg.enabled) {
+    void logLine('info', 'disabled', '插件自动更新被配置关掉了（enabled=false）');
+    return;
+  }
+
+  // 启动后第一次：等宿主把市场路由挂完再动手。这一轮不受「今天跑过了」限制。
+  scheduleTimeout(() => void tick('boot'), Math.max(1000, cfg.delaySeconds * 1000));
+
+  // 之后每 30 秒看一眼「到点了吗 / 是不是还没成功」。只是一次读数，没到点立刻返回，
+  // 定时的「每天 09:30」「每 6 小时」才准点（2026-11-14 加设置页时改的）。
+  const tickIntervalMs = Math.max(30000, Math.min(300000, Math.round(cfg.tickMinutes * 60000)));
+  const interval = setInterval(() => void tick('tick'), tickIntervalMs);
+  if (typeof interval.unref === 'function') interval.unref();
+  handles.add(interval);
+
+  void currentConfig().then((conf) => {
+    const modeText =
+      conf.mode === 'daily'
+        ? `每天 ${conf.dailyAt} 检查`
+        : conf.mode === 'interval'
+          ? `每 ${conf.intervalHours} 小时检查`
+          : '每次打开 DSH 检查';
+    void logLine('info', 'armed', `已武装：${modeText}（启动后 ${cfg.delaySeconds}s 跑第一轮，距上次不足 ${cfg.bootMinIntervalMinutes} 分钟则跳过；每 ${Math.round(tickIntervalMs / 1000)} 秒复查一次是否到点）`, {
+      mode: conf.mode,
+      autoApply: conf.autoApply,
+      popupEnabled: conf.popupEnabled,
+    });
+  });
+
+  // ------------------------------------------------------------ 一键修复（关插件 → 更新 → 重启）
+
+  const fixJob = { running: false, startedAt: null, steps: [], done: false, error: null };
+
+  function pluginManagerService() {
+    try {
+      if (ctx && typeof ctx.get === 'function') return ctx.get('pluginManager') || null;
+      return ctx.pluginManager || null;
+    } catch {
+      return null;
+    }
+  }
+
+  async function fixAndRestart() {
+    if (fixJob.running) return { ok: false, error: '已经有一轮修复在跑了' };
+    fixJob.running = true;
+    fixJob.done = false;
+    fixJob.error = null;
+    fixJob.steps = [];
+    fixJob.startedAt = new Date().toISOString();
+    try {
+      const state = await readState();
+      const last = state.lastResult || {};
+      const blockers = [
+        ...new Set(
+          (Array.isArray(last.failed) ? last.failed : [])
+            .filter((item) => item && item.inUse === true && item.name)
+            .map((item) => item.name),
+        ),
+      ];
+      await logLine('info', 'fix-start', `开始修复：${blockers.length ? blockers.join('、') : '（没有正在使用的插件）'}`);
+      const pm = pluginManagerService();
+      for (const name of blockers) {
+        if (!pm || typeof pm.setBundleEnabled !== 'function') {
+          fixJob.steps.push({ name, step: 'disable', ok: false, error: '拿不到 pluginManager，无法关闭插件' });
+          continue;
+        }
+        try {
+          const result = await pm.setBundleEnabled(name, false);
+          fixJob.steps.push({ name, step: 'disable', ok: true, application: result && result.application });
+        } catch (error) {
+          fixJob.steps.push({ name, step: 'disable', ok: false, error: errText(error) });
+        }
+      }
+      // 给卸载留一点时间，再让市场重试这几个。
+      await sleep(1500);
+      const round = await tick('fix', { force: true });
+      const applied = ((round && round.result && round.result.applied) || []).map((item) => `${item.name} → ${item.installed || item.to || '?'}`);
+      const failed = ((round && round.result && round.result.failed) || []).map((item) => `${item.name}（${item.message || item.code || '失败'}）`);
+      fixJob.steps.push({ step: 'update', ok: applied.length > 0 && failed.length === 0, applied, failed });
+      // 关掉的插件要装回来（是否真的能重载另说，重启后一定是开的）。
+      for (const name of blockers) {
+        if (!pm || typeof pm.setBundleEnabled !== 'function') break;
+        try {
+          await pm.setBundleEnabled(name, true);
+        } catch {
+          /* 重启后由 profile 里的选择决定，这里失败不影响 */
+        }
+      }
+      const restart =
+        blockers.length > 0 || applied.length > 0
+          ? scheduleDesktopRestart({ delayMs: 1500 })
+          : { ok: false, reason: '没有需要重启的变化' };
+      fixJob.steps.push({ step: 'restart', ...restart });
+      fixJob.done = true;
+      await logLine('info', 'fix-done', `修复完成：装上 ${applied.length} 个，失败 ${failed.length} 个，重启 ${restart.ok ? '已安排' : '未安排'}`);
+      return { ok: true, steps: fixJob.steps, restart };
+    } catch (error) {
+      fixJob.error = errText(error);
+      await logLine('error', 'fix-failed', fixJob.error);
+      return { ok: false, error: fixJob.error };
+    } finally {
+      fixJob.running = false;
+    }
+  }
+
+  // ------------------------------------------------------------ GUI 路由（/dsh-auto-update/*）
+
+  function sendJson(res, status, body) {
+    try {
+      res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store',
+      });
+      res.end(JSON.stringify(body));
+    } catch {
+      try {
+        res.end('{}');
+      } catch {
+        /* 连接已断 */
+      }
+    }
+  }
+
+  function readBody(req) {
+    return new Promise((resolve) => {
+      let size = 0;
+      const chunks = [];
+      req.on('data', (chunk) => {
+        size += chunk.length;
+        if (size > 64 * 1024) return;
+        chunks.push(chunk);
+      });
+      req.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        try {
+          resolve(text ? JSON.parse(text) : {});
+        } catch {
+          resolve({});
+        }
+      });
+      req.on('error', () => resolve({}));
+    });
+  }
+
+  async function tailLog(limit) {
+    try {
+      const text = await readFile(logPath, 'utf8');
+      return text
+        .trim()
+        .split('\n')
+        .slice(-limit)
+        .filter((line) => line.trim())
+        .map((line) => {
+          try {
+            const entry = JSON.parse(line);
+            return { at: entry.at, level: entry.level, event: entry.event, message: entry.message || '' };
+          } catch {
+            return { at: null, level: 'info', event: 'raw', message: clip(line, 400) };
+          }
+        })
+        .reverse();
+    } catch {
+      return [];
+    }
+  }
+
+  async function statusPayload() {
+    const state = await readState();
+    const conf = await currentConfig();
+    const today = localDay();
+    const pending =
+      state.popupPending && state.popupPending.day === today && state.popupAckDay !== today ? state.popupPending : null;
+    return {
+      ok: true,
+      running,
+      today,
+      config: conf,
+      last: state.lastResult || null,
+      popup: pending ? { show: true, day: pending.day, at: pending.at, result: pending.result } : { show: false },
+      state: {
+        lastDay: state.lastDay || null,
+        lastCheckAt: state.lastCheckAt || null,
+        skipUntil: state.skipUntil || null,
+        pendingRefresh: Array.isArray(state.pendingRefresh) ? state.pendingRefresh : [],
+        attempts: state.attempts || null,
+      },
+      desktop: desktopLaunchInfo(),
+      fix: fixJob,
+    };
+  }
+
+  try {
+    ctx.effect(() =>
+      ctx.webServer.register({
+        kind: 'prefix',
+        path: '/dsh-auto-update',
+        async handler(req, res) {
+          const url = new URL(String(req.url || '/'), 'http://127.0.0.1');
+          const route = url.pathname.replace(/\/+$/, '') || '/dsh-auto-update';
+          try {
+            if (req.method === 'GET' && (route === '/dsh-auto-update' || route === '/dsh-auto-update/status')) {
+              return sendJson(res, 200, await statusPayload());
+            }
+            if (req.method === 'GET' && route === '/dsh-auto-update/log') {
+              const limit = Math.max(1, Math.min(200, Number(url.searchParams.get('limit')) || 30));
+              return sendJson(res, 200, { ok: true, entries: await tailLog(limit) });
+            }
+            if (req.method === 'POST' && route === '/dsh-auto-update/run') {
+              const outcome = await tick('manual', { force: true });
+              return sendJson(res, 200, {
+                ok: !(outcome && outcome.error),
+                skipped: (outcome && outcome.skipped) || null,
+                error: (outcome && outcome.error) || null,
+                result: (outcome && outcome.result) || null,
+              });
+            }
+            if (req.method === 'POST' && route === '/dsh-auto-update/config') {
+              const body = await readBody(req);
+              const saved = await saveConfig(body);
+              return sendJson(res, 200, { ok: true, config: saved });
+            }
+            if (req.method === 'POST' && route === '/dsh-auto-update/popup/ack') {
+              const state = await readState();
+              state.popupAckDay = localDay();
+              state.popupPending = null;
+              await writeState(state);
+              return sendJson(res, 200, { ok: true });
+            }
+            if (req.method === 'POST' && route === '/dsh-auto-update/fix') {
+              // 修复要关插件、等市场重装、再拉起重启，可能几分钟；这里只负责开跑，结果让前端轮询 /status。
+              if (fixJob.running) return sendJson(res, 409, { ok: false, error: '已经有一轮修复在跑了' });
+              void fixAndRestart();
+              return sendJson(res, 200, { ok: true, started: true });
+            }
+            return sendJson(res, 404, { ok: false, error: `未知路由 ${req.method} ${route}` });
+          } catch (error) {
+            return sendJson(res, 500, { ok: false, error: errText(error) });
+          }
+        },
+      }),
+    );
+  } catch (error) {
+    void logLine('error', 'gui-register-failed', errText(error));
+  }
+
+  // ------------------------------------------------------------ 查询 / 手动触发工具
+
+  try {
+    const tools = ctx.tools; // 靠 inject: ['tools'] 注入；以前这里 ctx.get('tools') 恒为空，工具从没注册成功
+    if (!tools || typeof tools.register !== 'function') throw new Error('tools 服务不可用（inject 没生效？）');
+    ctx.effect(() =>
+      tools.register({
+          name: 'dsh_auto_update_status',
+          description:
+            '查看「每天自动检查并安装插件市场更新」这次/上次跑的结果，记录文件在 ~/.dsh/auto-update/state.json；传 run=true 可以立刻手动跑一轮（会真的安装更新）。',
+          parameters: {
+            type: 'object',
+            properties: {
+              run: { type: 'boolean', description: 'true = 现在立刻检查并安装（忽略「今天已经跑过」的限制）' },
+              logLines: { type: 'number', description: '附带多少条最近日志，默认 10，最多 50' },
+            },
+            additionalProperties: false,
+          },
+          output: {
+            schema: {
+              type: 'object',
+              properties: {
+                ok: { type: 'boolean' },
+                running: { type: 'boolean' },
+                skipped: { type: 'string' },
+                summary: { type: 'string' },
+                state: { type: 'object' },
+                log: { type: 'array', items: { type: 'string' } },
+              },
+              additionalProperties: true,
+            },
+            render(args, value) {
+              const v = value || {};
+              return [{ type: 'text', text: typeof v.summary === 'string' && v.summary ? v.summary : '（没有结果）' }];
+            },
+          },
+          isConcurrencySafe: () => true,
+          timeoutMs: 1200000,
+          async execute(args) {
+            const input = args && typeof args === 'object' ? args : {};
+            let last = null;
+            let skipped = null;
+            if (input.run === true) {
+              const outcome = await tick('manual', { force: true });
+              if (outcome && outcome.skipped) skipped = outcome.skipped;
+              if (outcome && outcome.result) last = outcome.result;
+            }
+            const state = await readState();
+            const seen = last || state.lastResult || null;
+            const lines = [];
+            const limit = Math.max(1, Math.min(50, num(input.logLines, 10, 1, 50)));
+            try {
+              const text = await readFile(logPath, 'utf8');
+              for (const line of text.trim().split('\n').slice(-limit)) {
+                if (!line.trim()) continue;
+                try {
+                  const entry = JSON.parse(line);
+                  lines.push(`${entry.at} [${entry.level}] ${entry.event} ${entry.message || ''}`.trim());
+                } catch {
+                  lines.push(clip(line, 300));
+                }
+              }
+            } catch {
+              /* 没有日志文件就留空 */
+            }
+            const summary = buildSummary(seen, state, skipped, running);
+            const payload = {
+              ok: !seen || !Array.isArray(seen.failed) || seen.failed.length === 0,
+              running,
+              summary,
+              state: {
+                lastDay: state.lastDay || null,
+                lastCheckAt: state.lastCheckAt || null,
+                skipUntil: state.skipUntil || null,
+                attempts: state.attempts || null,
+                pendingRefresh: Array.isArray(state.pendingRefresh) ? state.pendingRefresh : [],
+              },
+              log: lines,
+            };
+            if (skipped) payload.skipped = String(skipped);
+            return payload;
+          },
+        }),
+      );
+  } catch (error) {
+    // 别静默吞：工具没注册上正是今天这个 bug 的表现，写进日志才查得到。
+    void logLine('error', 'tool-register-failed', errText(error));
+  }
+
+  function buildSummary(result, state, skipped, isRunning) {
+    const lines = [];
+    if (isRunning) lines.push('⏳ 正在跑一轮更新…');
+    if (skipped) lines.push(`本轮跳过：${skipped}`);
+    if (result) {
+      lines.push(`上次检查：${localTime(result.at)}（触发=${result.reason || '?'}）`);
+      lines.push(`市场：${result.marketVersion || '?'} @ ${result.base || '?'}`);
+      lines.push(`扫了 ${result.checked} 个插件，可更新 ${result.updatable} 个`);
+      for (const item of result.applied || []) lines.push(`✅ ${item.name} ${item.from || '?'} → ${item.installed || item.to || '?'}`);
+      for (const item of result.failed || []) lines.push(`❌ ${item.name} ${item.code || item.state || ''} ${clip(item.message || '', 200)}`);
+      for (const item of Array.isArray(result.deferred) ? result.deferred : []) {
+        lines.push(`⏸ ${item.name} ${item.reason || '等 agent 空闲后再装'}`);
+      }
+      if (result.note) lines.push(`说明：${result.note}`);
+    } else {
+      lines.push('还没有跑过（每次打开 DSH 会检查一轮，也可以传 run=true 立刻跑）。');
+    }
+    if (state && state.lastDay) lines.push(`${state.lastDay} 的自动检查已完成；下次开机还会再查一轮`);
+    if (state && state.skipUntil) lines.push(`下次自动重试不早于：${localTime(state.skipUntil)}`);
+    if (state && Array.isArray(state.pendingRefresh) && state.pendingRefresh.length > 0) {
+      lines.push(`已更新但需重启 DSH 生效：${state.pendingRefresh.join('、')}`);
+    }
+    lines.push('提示：新发布的版本要过 24 小时（pnpm minimumReleaseAge）才会被市场报成可更新，所以通常晚一天装。');
+    return lines.join('\n');
+  }
+}