dsh-wisp 1.42.0 → 1.44.0

package/lib/client.template.js

@@ -51,7 +51,7 @@ window.__ModuleLoader__.load({
     var exports = module.exports
     Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 
-    const VERSION = '1.42.0'
+    const VERSION = '1.44.0'
 
 /* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
    忘了更新就会红，不会静默过期。 */
@@ -86,6 +86,12 @@ const WHATS_NEW = {
   '1.40.0': '她的透明处真的点不到了：按轮廓命中，站在按钮上也不挡你点它。',
   '1.41.0': '检查更新更耐得住：一个源连不上不再把另一个拖死，失败时 doctor() 会说清是哪个源、为什么。',
   '1.42.0': '查更新失败时她会直接说清是哪一种：没通道 / 连不上 / 宿主没应答。',
+  '1.43.0': '一批"真的用鼠标点过一遍"才发现的问题：拨完开关面板不再消失、大小能调回出厂值、触摸与指针离开不再留姿势、静止档真的会停。',
+  '1.43.1': '检查更新多了一条兜底通道（问插件管理器），并且失败时会直接说出"为什么拿不到"。',
+  '1.43.2': '台词只说人话；查不成的原因排进「关于她」弹窗，不再往句子里塞英文碎片。',
+  '1.44.0': '查更新改成客户端自己抓（bundle 插件没有 host RPC 座位）—— 这才是它一直缺的那条路。',
+  '1.43.4': '把查更新失败时的诊断临时写进窗口标题，供定位用。',
+  '1.43.3': '把"没接上宿主"和"宿主没有网络通道"分成两句 —— 断在哪一环，一句话就看得出来。',
 }
 
 /* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
@@ -95,6 +101,11 @@ const WHATS_NEW = {
    所以这里只做三件真能做的事：报版本、说她更新了、把包名复制给你去 DSH 里装。 */
 const SEEN_VERSION_KEY = 'dsh-wisp:seen-version:v1'
 const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
+/* 但"按包名安装"只在 npm 上已经有这一版时成立。npm 暂存（或还没发）而 GitHub
+   已经更新时，照那句话装回来的是**旧版** —— 她得改口，并复制仓库地址而不是包名。
+   她本来就知道这个版本号是从哪个源读到的（updateCheck.from / sources）。 */
+const UPDATE_REPO = 'https://github.com/969246694/dsh-wisp'
+const UPDATE_HINT_GITHUB = 'npm 上还是旧版，用这个地址装 dsh-wisp：' + UPDATE_REPO
 
     /* ---- sprites: 256x384 WebP, transparent, inlined by build.mjs ---- */
     const SPRITES = __SPRITES_LITERAL__
@@ -411,6 +422,11 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
          「宿主那边没应答」是三件事，含糊地说成"没查到"就没人能追下去 ——
          而用户看到的恰恰只有那一句。 */
       updateNoChannel: ['这个壳里我没有联网的通道，查不了更新。', '这里没有能出去的网络通道。'],
+      /* 两种"没通道"必须分开说 —— 它们是链路上**不同的一环**断了：
+         · 没接上宿主半包（客户端这一侧连 `host.call` 都没有）
+         · 宿主跑了，但它拿不到 `web` 服务
+         合并成一句话的代价是：谁也说不清断在哪一环（这个坑真踩过）。 */
+      updateNoSeat: ['我没接上宿主半包，查不了更新。', '宿主那边没接上，查不了更新。'],
       updateNoHost: ['宿主那边没应答，更新没查成。', '问不到宿主，更新没查成。'],
       milestone: [
         '今天第 {n} 轮了。', '{n} 轮了，还不错。', '已经 {n} 轮了，你挺能撑。',
@@ -470,6 +486,7 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       streak: ['{n} days in a row.', 'Day {n} together.'],
       updateFailed: ["The update check didn't work.", "Couldn't reach the update sources."],
       updateNoChannel: ["This shell gives me no network channel, so I can't check for updates.", 'No way out to the network from here.'],
+      updateNoSeat: ["I'm not connected to my host half, so I can't check for updates.", 'No host half attached.'],
       updateNoHost: ["The host side didn't answer — the update check failed.", 'No answer from the host.'],
       balanceChecking: ['One moment…', 'Let me check.'],
       balance: ['Balance: {n}.', "You've got {n}.", '{n} on the account.'],
@@ -891,6 +908,8 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 .wisp-root[data-motion="off"]{--wisp-amp:0}
 /* 静止档：连呼吸和 z 都停 —— 她说"我不想让她动"时，是最彻底的静止。 */
 .wisp-root[data-motion="off"] .wisp-body,.wisp-root[data-motion="off"] .wisp-zzz{animation:none}
+/* 但"不动"不等于"冻住"：动画一关，z 会停在满不透明的初始态，看起来像一个卡住的字 */
+.wisp-root[data-motion="off"] .wisp-zzz{opacity:.5}
 .wisp-root[data-accent="press"] .wisp-motion{animation:wisp-press .2s ease-out}
 .wisp-root[data-accent="land"] .wisp-motion{animation:wisp-land .56s cubic-bezier(.2,1.15,.35,1)}
 .wisp-root[data-accent="pop-a"] .wisp-motion{animation:wisp-pop-a .38s ease-out}
@@ -976,7 +995,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 .wisp-credits{font-size:11px;opacity:.8;margin:6px 0 0}
 .wisp-dialog-action{display:block;width:100%;margin:4px 0 2px;padding:7px 10px;border:1px solid var(--dsw-alias-border-l1,var(--wisp-say-line));border-radius:8px;background:none;color:inherit;font:inherit;cursor:pointer}
 .wisp-dialog-action:hover{background:var(--dsw-alias-bg-layer-2,rgba(120,170,255,.2))}
-@media (prefers-reduced-motion:reduce){.wisp-body{animation:none!important}.wisp-motion{animation:none!important}.wisp-lean{transform:none!important;transition:none!important}.wisp-menu,.wisp-submenu,.wisp-switch,.wisp-switch i,.wisp-slider-knob,.wisp-menu-item,.wisp-corner{animation:none!important;transition:none!important}}`
+@media (prefers-reduced-motion:reduce){.wisp-body{animation:none!important}.wisp-motion{animation:none!important}.wisp-zzz{animation:none!important;opacity:.5}.wisp-lean{transform:none!important;transition:none!important}.wisp-menu,.wisp-submenu,.wisp-switch,.wisp-switch i,.wisp-slider-knob,.wisp-menu-item,.wisp-corner{animation:none!important;transition:none!important}}`
 
     const installStyles = (styles) => {
       if (styles && typeof styles.insert === 'function') {
@@ -1601,7 +1620,11 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 
       /* 结构：body（情绪动画）> motion（一次性动作）> lean（姿势）> shine/img，
       外加一个兄弟节点 hit（命中层）。 */
-      leanEl.appendChild(shine)
+      /* 光晕（脚底那圈光）挂在 motion 层、**不在 lean 层**：它是地面上的东西，
+         不该跟着她的侧身一起歪 —— 挂在 lean 里的时候，她一倾斜光圈也跟着转，
+         看起来像地板歪了。但按下/落地那一下的压扁它该跟着（那是"她压在地上"），
+         所以留在 motion 层而不是提到 body 层。 */
+      motionEl.appendChild(shine)
       leanEl.appendChild(img)
       motionEl.appendChild(leanEl)
       bodyEl.appendChild(motionEl)
@@ -2316,6 +2339,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       let wanderHandle = null
       const syncWander = () => {
         if (wanderHandle) { clock.cancel(wanderHandle); wanderHandle = null }
+        /* 溜达也是"动作"：`motion: off` 和 prefers-reduced-motion 都该让她待在原地。
+           之前只关了 CSS 动画，她照样会自己滑走 —— 那是最容易被忽略的一种"没停下来"，
+           因为看起来只是一次正常的挪动。（CSS 关不掉 JS 写进去的坐标。） */
+        if (cfg.motion === 'off' || reduced()) return
         if (!cfg.wander || cfg.wanderRange <= 0 || paused) return
         wanderHandle = clock.every(cfg.wanderMs, () => {
           if (destroyed || hidden || mood !== 'idle' || start !== null) return
@@ -2424,8 +2451,17 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         const dx = e.clientX - start.x, dy = e.clientY - start.y
         if (!moved && Math.sqrt(dx * dx + dy * dy) > 4) moved = true
         if (!moved) return
+        const beforeX = coords.x, beforeY = coords.y
         coords.x = clamp(origin.x + dx, 0, maxX())
         coords.y = clamp(origin.y + dy, 0, maxY())
+        /* 被边界夹住时她其实**没有动** —— 这时候再按指针位移去倾，就是"原地歪"，
+           看起来像坏了。位置没变就把姿势归零（指针继续拖也不影响，因为下一帧
+           只要真的动了就会重新算）。 */
+        if (coords.x === beforeX && coords.y === beforeY) {
+          lastDragX = e.clientX
+          setTilt(0)
+          return
+        }
         /* 拖动时她朝**运动的反方向**倾：被拎着走的东西，顶是往后倒的。
            只看"这一次事件走了多远"就等价于速度，不用存历史、不用积分 ——
            而且它天然跟着指针事件的频率走，慢拖就是小角度。 */
@@ -2512,6 +2548,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (destroyed || paused || hidden || start !== null) return
         if (mood === 'sleep') return
         if (cfg.motion === 'off' || reduced()) return
+        /* 触摸屏上"指针"就是手指：手指划过时让她整只歪过去是错的 ——
+           那既不是"靠近"也不是"路过"，而且手指一抬起姿势就冻在那儿。
+           所以触摸一律归零（真正该有的反馈是"按下压一下"，那是另一条通道）。 */
+        if (e.pointerType === 'touch') { setTilt(0); return }
         if (typeof e.clientX !== 'number' || typeof e.clientY !== 'number') return
         const dx = e.clientX - (coords.x + boxW() / 2)
         const dy = e.clientY - (coords.y + boxH() / 2)
@@ -2522,9 +2562,16 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       }
       window.addEventListener('pointermove', leanToPointer, { passive: true })
       /* 指针移出窗口、或者你切走应用之后，不会再有点事件来把它归零 ——
-         没有这一下，她会一直朝着最后那个位置歪着。 */
+         没有这一下，她会一直朝着最后那个位置歪着。
+         `blur` 只覆盖"切走应用"，**指针移出窗口不会触发它** —— 补一个文档级
+         mouseleave（指针离开文档时才发），两条一起才真的覆盖到。 */
       const resetTilt = () => setTilt(0)
       window.addEventListener('blur', resetTilt)
+      try {
+        if (typeof document !== 'undefined' && document.addEventListener) {
+          document.addEventListener('mouseleave', resetTilt)
+        }
+      } catch (e) { /* 没有 document：她最多保留最后一次侧身，不影响其它功能 */ }
 
       /* 键盘入口：Enter / Space / 菜单键 / Shift+F10 打开菜单。
          Space 默认会滚动页面，Enter 在表单里会提交 —— 都要拦。 */
@@ -2564,7 +2611,11 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
          只认**带修饰键**的滚轮：她占地不小，直接吞掉普通滚轮等于在她身上把页面滚动禁掉。
          带修饰键是「缩放」的通行手势，此时 preventDefault 才是帮忙而不是捣乱。
          步长 0.25，上下限由 CONFIG_SPEC 统一夹紧（0.4–8），不在这里再写一遍。 */
-      const WHEEL_STEP = 0.25
+      /* 步长必须是"默认值可达"的：size 的区间是 0.4–8，默认 2.5。
+         原来键盘/滚轮步长 0.25，可达值只有 0.4 + 0.25k —— **2.5 不在格点上**
+         （最近的是 2.4 / 2.65），于是用户只要动过一次滑块，就再也调不回出厂大小。
+         0.1 让 2.5 正好落在格点上（0.4 + 21×0.1）。预检里有一条守着这个不变式。 */
+      const WHEEL_STEP = 0.1
       const onWheel = (ev) => {
         if (!ev.ctrlKey && !ev.metaKey) return          // 普通滚轮原样放行
         if (typeof ev.preventDefault === 'function') ev.preventDefault()
@@ -2875,12 +2926,17 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
          子面板里的开关点完必须留在原地 —— 拨个开关面板就消失是最烦人的交互之一。 */
       const refreshSurfaces = () => {
         const keep = flyoutName
+        /* 重画之前先记住"这个面板是点开的还是悬停开的"：openMenu 里的 closeFlyout()
+           会把标记清掉，不记下来，拨一次开关后面板就从"钉住"降级成"悬停开启" ——
+           而重画出来的 DOM 里鼠标并没有真的悬停过，宽限期一到面板就自己关了。
+           用户看到的现象就是：拨个开关，面板消失（而这正是这段注释上面说不能有的）。 */
+        const keepPinned = flyoutPinned
         const keepIndex = flyoutRow && flyoutRow.dataset ? Number(flyoutRow.dataset.rowIndex) : -1
         openMenu(menuAtX, menuAtY, false)          // 重画菜单（会先关掉面板）
         if (!keep || !menuEl) return
         const row = menuEl.querySelectorAll('.wisp-menu-item')
           .find((el) => el.dataset && el.dataset.group === keep)
-        if (row) openFlyout(keep, row, Number.isFinite(keepIndex) && keepIndex >= 0 ? keepIndex : Number(row.dataset.rowIndex))
+        if (row) openFlyout(keep, row, Number.isFinite(keepIndex) && keepIndex >= 0 ? keepIndex : Number(row.dataset.rowIndex), keepPinned)
       }
 
       const openFlyout = (name, rowEl, index, pinned) => {
@@ -3160,7 +3216,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         ])
       }
 
-      const aboutDialog = () => {
+      const aboutDialog = (diagRes) => {
         const note = WHATS_NEW[VERSION]
         /* 菜单里那条「版本与更新」已经收掉了（版本号现在直接显示在菜单头部），
            所以检查更新必须有新的入口 —— 放在这里，上下文正合适。 */
@@ -3180,9 +3236,12 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           para('她还能陪你专注计时：菜单里开一段 25 或 45 分钟，期间她保持"干活中"，戳她一下是问还剩多久，到点她替你收工。'),
           para('这一版：' + (note || VERSION)),
           para('形象与设定参考社区项目 Neko3000/deepseek-whalechan（设定文档 CC BY-NC-SA 4.0，原作者 B站 ZipZipPipe、上善无形）。'),
+          /* 上一次检查更新失败时，把宿主看到的东西摆在最显眼的位置 —— 台词只有一句，
+             而"为什么拿不到"必须能被看到、被复制、被追问。 */
+          diagRes ? para('上次查更新为什么没成：\n' + describeDiag(diagRes)) : null,
           checkBtn,
           dialogFoot('非官方同人作品，与 DeepSeek 官方无关', 'v' + VERSION),
-        ])
+        ].filter(Boolean))
       }
 
       /* 菜单的结构 ------------------------------------------------------------
@@ -3475,7 +3534,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           if (focused && focused.dataset && focused.dataset.slider === '1'
             && (ev.key === 'ArrowLeft' || ev.key === 'ArrowRight')) {
             if (typeof ev.preventDefault === 'function') ev.preventDefault()
-            const step = ev.shiftKey ? 1 : 0.25
+            const step = ev.shiftKey ? 1 : 0.1
             applyConfig({ size: cfg.size + (ev.key === 'ArrowRight' ? step : -step) })
             /* 只更新滑块自身，不重画整张菜单 —— 焦点和展开状态都不动 */
             try {
@@ -3692,6 +3751,9 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 
          host 是 shell 注入的名字，不是全局：拿不到就如实说"查不了"，不许抛。 */
       let updateCheck = { state: 'idle', at: 0 }
+      /* 上一次真正复制给用户的提示语（doctor 里能看到）—— "她让你装的是哪个" 必须可查，
+         否则"按包名安装"和"用 GitHub 地址装"这两条路到底走了哪条就没人说得清。 */
+      let lastUpdateHint = UPDATE_HINT
 
       const compareVersions = (a, b) => {
         const parse = (v) => String(v).split('-')[0].split('.').map((n) => {
@@ -3717,12 +3779,58 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         return null
       }
 
+      /* 客户端**自己的**通道 —— 这才是这个插件真正的联网方式。
+         
+         事实（从平台的 dsh-client-modules 加载器读出来的）：bundle 插件的客户端半包
+         是用 <script> 加载的**普通页面脚本**，平台不注入陷阱、不替换全局 —— 所以
+         `window.fetch` 对它可用。而 `host.call` 那个 RPC 座位只发给**动态插件**
+         （runner 里 `hasHostHalf: definition.hostCode !== undefined`），我们这个形态
+         从来没有过它。
+         
+         以前代码里写着"浏览器半包的 fetch 是陷阱"，那是把**预检替身**的契约当成了
+         平台契约 —— 整个更新检查因此在错误的路上走了很久（真机上永远"没接上宿主"）。 */
+      const NPM_LATEST_URL = 'https://registry.npmjs.org/dsh-wisp/latest'
+      const GITHUB_RAW_URL = 'https://raw.githubusercontent.com/969246694/dsh-wisp/main/package.json'
+      const clientVersionAt = (url) => {
+        try {
+          const fetcher = window.fetch
+          if (typeof fetcher !== 'function') return Promise.resolve(null)
+          return fetcher.call(window, url, { cache: 'no-store' })
+            .then((res) => (res && res.ok === true ? res.json() : null))
+            .then((data) => (data && typeof data.version === 'string' ? data.version : null))
+            .catch(() => null)
+        } catch (e) { return Promise.resolve(null) }
+      }
+
+      /* 客户端侧的完整检查：两个源各取一次，取更高的那个（与宿主侧同一套规则）。 */
+      const clientSideCheck = () => {
+        updateCheck = { state: 'checking', at: nowMs() }
+        return Promise.all([clientVersionAt(NPM_LATEST_URL), clientVersionAt(GITHUB_RAW_URL)])
+          .then(([npmVersion, githubVersion]) => {
+            const sources = {
+              npm: npmVersion ? { ok: true, version: npmVersion } : { ok: false, reason: 'fetch-failed' },
+              github: githubVersion ? { ok: true, version: githubVersion } : { ok: false, reason: 'fetch-failed' },
+            }
+            const cands = [['npm', npmVersion], ['github', githubVersion]].filter((p) => typeof p[1] === 'string')
+            if (cands.length === 0) {
+              updateCheck = { state: 'failed', reason: 'fetch-failed', sources, diag: null, at: nowMs() }
+              publishDiagToTitle(updateCheck)
+              return updateCheck
+            }
+            let best = cands[0]
+            for (const c of cands) if (compareVersions(best[1], c[1]) < 0) best = c
+            updateCheck = compareVersions(VERSION, best[1]) < 0
+              ? { state: 'available', latest: best[1], from: best[0], sources, at: nowMs() }
+              : { state: 'current', latest: best[1], from: best[0], sources, at: nowMs() }
+            return updateCheck
+          })
+      }
+
       const checkForUpdate = () => {
         const seat = hostSeat()
-        if (seat === null) {
-          updateCheck = { state: 'unsupported', at: nowMs() }
-          return Promise.resolve(updateCheck)
-        }
+        /* 没有 host 座位不是失败 —— 那是**这个形态的插件的常态**（bundle 插件没有 host RPC）。
+           客户端自己抓：这才是它本来该走的路。 */
+        if (seat === null) return clientSideCheck()
         updateCheck = { state: 'checking', at: nowMs() }
         return Promise.resolve()
           .then(() => seat.call('checkUpdate', { current: VERSION }))
@@ -3735,8 +3843,11 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
                 state: 'failed',
                 reason: (res && res.reason) || 'no-result',
                 sources: (res && res.sources) || null,
+                /* 宿主看到的诊断也要留下来 —— 失败台词会把它念出来，doctor 里也能查。 */
+                diag: (res && res.diag) || null,
                 at: nowMs(),
               }
+              publishDiagToTitle(updateCheck)
             } else if (compareVersions(VERSION, res.latest) < 0) {
               /* from / sources 一起留着：两个源不一致时（npm 暂存、GitHub 已更新），
                  "这个数字是哪儿来的"比数字本身更需要能查。 */
@@ -3838,17 +3949,73 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           })
       }
 
+      /* 版本号来自 GitHub，而 npm 上那份**不是同一个号**（通常是 npm 暂存或还没发）——
+         这时候"按包名安装"会把人送回旧版。 */
+      const githubOnlyNewer = (res) => {
+        if (!res || res.state !== 'available' || res.from !== 'github') return false
+        const npm = res.sources && res.sources.npm
+        return !!(npm && npm.ok === true && npm.version !== res.latest)
+      }
+
       const updateLine = (res) => {
         if (res.state === 'available') return pick(LINES.updateAvailable) + res.latest
         if (res.state === 'current') return pick(LINES.updateCurrent)
         /* 失败要说清是哪一种：没有通道 / 连不上 / 宿主没应答。
            `no-web-service` 是"这个壳根本没有联网入口"，不是"网络不好"——
            以前两者共用一句"没查到更新"，于是诊断只能靠猜。 */
-        if (res.state === 'unsupported' || res.reason === 'no-web-service') return pick(LINES.updateNoChannel)
+        /* 失败要说清是哪一种 —— 它们是链路上**不同的一环**断了：
+           `unsupported`：客户端这侧连 `host.call` 都没有（第一环）；
+           `no-web-service`：宿主跑了，但它拿不到 `web` 服务（第三环）；
+           `fetch-failed`：服务拿到了，两个源都连不上（第四环）。 */
+        if (res.state === 'unsupported') return pick(LINES.updateNoSeat)
+        if (res.reason === 'no-web-service') return pick(LINES.updateNoChannel)
         if (res.reason === 'call-failed') return pick(LINES.updateNoHost)
         return pick(LINES.updateFailed)
       }
 
+      /* 技术的部分**不进台词**（台词是给人读的一句话，塞进去就是一串英文碎片），
+         但必须看得见 —— 失败时把宿主实际看到的排进「关于她」弹窗：
+         取服务的方式、拿到的东西是什么形状、兜底通道为什么也不行。
+         这是"她说查不了"和"我知道为什么"之间的那一步。 */
+      /* 诊断的**临时出口**：把"宿主看见了什么"写进窗口标题。
+         Agent 侧读一下窗口标题就能拿到（不用截图、不用控制台、不用用户复制）——
+         这台机器上的断点已经卡了两轮，值得开一个临时通道把它钉死。
+         120 秒后自动还原；定位到问题后这一条会撤掉。 */
+      let diagTitleTimer = null
+      const publishDiagToTitle = (res) => {
+        try {
+          if (typeof document === 'undefined' || !document || typeof document.title !== 'string') return
+          const diag = (res && res.diag) || {}
+          const short = [
+            'wisp-diag',
+            String((res && res.state) || '?'),
+            String((res && res.reason) || '-'),
+            'via=' + String(diag.via || '-'),
+            'how=' + String(diag.how || '-'),
+            'why=' + String(diag.why || '-'),
+            'mgr=' + String(diag.manager || '-'),
+          ].join(' ')
+          const original = document.title
+          document.title = short
+          if (diagTitleTimer !== null) clock.cancel(diagTitleTimer)
+          diagTitleTimer = clock.timeout(() => {
+            try { document.title = original } catch (e) { /* ignore */ }
+            diagTitleTimer = null
+          }, 120000)
+        } catch (e) { /* 标题写不了不该影响任何别的功能 */ }
+      }
+
+      const describeDiag = (res) => {
+        const diag = res && res.diag
+        if (!diag || typeof diag !== 'object') return '这次连诊断信息都没有拿到。'
+        const lines = ['通道：' + String(diag.via || '未知')]
+        if (diag.how) lines.push('取服务的方式：' + String(diag.how))
+        if (diag.why) lines.push('看到的东西：' + String(diag.why))
+        if (diag.registry) lines.push('插件管理器的 registry：' + String(diag.registry))
+        if (diag.manager) lines.push('兜底通道：' + String(diag.manager))
+        return lines.join('\n')
+      }
+
       /* 把包名复制到剪贴板，便于在 DSH 的「按插件包名安装」里粘贴。
          没有剪贴板权限（或不是安全上下文）时**静默降级**成只说话 —— 不该因此报错。 */
       const copyText = (text) => {
@@ -3868,6 +4035,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
          用户点这一项想知道的就是这两件事。 */
       const showUpdate = () => {
         const note = WHATS_NEW[VERSION]
+        let hint = UPDATE_HINT
         const copied = copyText('dsh-wisp')
         /* 一步到位：先把"我是谁、这一版做了什么"说出来，同时去查有没有新版；
            查回来再用一句话覆盖掉 —— 一次只冒一个气泡，所以是"说完结果就结束"。 */
@@ -3878,9 +4046,18 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           started.then((res) => {
             if (destroyed) return
             if (res.state === 'checking') return
+            /* 新版只在 GitHub 上 → 改口 + 把仓库地址放进剪贴板（包名会装回旧版）。 */
+            if (githubOnlyNewer(res)) {
+              hint = UPDATE_HINT_GITHUB
+              lastUpdateHint = hint
+              copyText(UPDATE_REPO)
+            }
             flashHappy(base + updateLine(res))
+            /* 查不成的时候：把"为什么"摆到弹窗里（台词只留一句人话）。 */
+            if (res.state === 'failed') aboutDialog(res)
           })
         }
+        lastUpdateHint = hint
         return { version: VERSION, note: note || null, copied, checking: true }
       }
 
@@ -4040,7 +4217,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
               version: VERSION,
               whatsNew: WHATS_NEW[VERSION] ?? null,
               seenBefore: readStored(SEEN_VERSION_KEY),
-              hint: UPDATE_HINT,
+              hint: lastUpdateHint,
               canSelfUpdate: false,
               /* 上一次检查的结果（idle / checking / current / available / failed / unsupported） */
               lastCheck: { ...updateCheck },

package/lib/index.js

@@ -32,7 +32,7 @@
 export const name = 'wisp'
 
 /** Stamped into every balance request. Must match package.json — the preflight guards it. */
-export const VERSION = '1.42.0'
+export const VERSION = '1.44.0'
 
 /**
  * `web` and `deepseekAccount` are optional on purpose. A required inject that
@@ -50,8 +50,23 @@ export const DEFAULT_SOURCES = {
 /** How long ONE source may take before it is reported as a timeout. */
 const CHECK_TIMEOUT_MS = 8000
 
+/** 这个包自己的名字 —— 兜底通道（问插件管理器）按包名查。 */
+const UPDATE_PACKAGE_NAME = 'dsh-wisp'
+
+/** 一眼看懂一个"服务"到底是什么（诊断用；永远不抛）。 */
+function describeService(value) {
+  if (value === undefined) return 'undefined'
+  if (value === null) return 'null'
+  const type = typeof value
+  if (type !== 'object' && type !== 'function') return type
+  try {
+    const keys = Object.keys(value).slice(0, 6).join(',')
+    return type + '{' + keys + '}' + (typeof value.fetch === 'function' ? '+fetch' : '-fetch')
+  } catch (error) { return type + '(unreadable)' }
+}
+
 /**
- * Resolve the `web` service LATE, on every call.
+ * Resolve the `web` service LATE, on every call — and say HOW, and what was found.
  *
  * `inject.optional: ['web']` hands us `ctx.web`, but only when the service was
  * already provided at the moment this fiber materialized — and this half is
@@ -60,20 +75,75 @@ const CHECK_TIMEOUT_MS = 8000
  * which would disable the update check forever. `ctx.get('web')` looks the
  * service up at call time instead, so a startup race cannot wedge it.
  *
- * @returns the service, or undefined when this shell really has none.
+ * 真实运行里两种路都拿不到时，**必须能说清是哪一种**：`ctx.get` 有没有？
+ * 拿到的东西是什么形状？—— 没有这一层，"没有联网的通道"是一句无法追问的话。
+ *
+ * @returns `{ service, how, why }` — never throws.
+ *   how: 'ctx.get' | 'ctx.web' | 'none'   拿到了没有、从哪拿的
+ *   why: 一句话说明"看到了什么"（进了 doctor 与她的失败台词）
  */
 export function resolveWebService(ctx) {
+  let late
+  let getThrew = null
   try {
-    if (ctx && typeof ctx.get === 'function') {
-      const late = ctx.get('web')
-      if (late && typeof late.fetch === 'function') return late
-    }
-  } catch (error) { /* restricted context: fall through to the declared property */ }
+    if (ctx && typeof ctx.get === 'function') late = ctx.get('web')
+    else getThrew = 'ctx.get 不是函数（' + describeService(ctx && ctx.get) + '）'
+  } catch (error) { getThrew = 'ctx.get 抛错：' + String(error && error.message ? error.message : error).slice(0, 60) }
+  if (late && typeof late.fetch === 'function') {
+    return { service: late, how: 'ctx.get', why: 'ctx.get("web")→' + describeService(late) }
+  }
+  let declared
+  let webThrew = null
+  try { declared = ctx && ctx.web } catch (error) { webThrew = String(error && error.message ? error.message : error).slice(0, 60) }
+  if (declared && typeof declared.fetch === 'function') {
+    return { service: declared, how: 'ctx.web', why: 'ctx.web→' + describeService(declared) }
+  }
+  const parts = []
+  parts.push('ctx.get("web")→' + describeService(late))
+  if (getThrew) parts.push(getThrew)
+  parts.push('ctx.web→' + describeService(declared))
+  if (webThrew) parts.push('ctx.web 读取抛错：' + webThrew)
+  /* 拿到了对象但没有 fetch 也要如实说 —— "有服务但没这个方法"和"根本没有服务"是两件事 */
+  const service = (late && typeof late === 'object') ? late : ((declared && typeof declared === 'object') ? declared : undefined)
+  if (service) {
+    return { service, how: 'partial', why: parts.join('; ') + '（无 fetch）' }
+  }
+  return { service: undefined, how: 'none', why: parts.join('; ') }
+}
+
+/**
+ * 兜底通道：向插件管理器问"这个包现在是什么版本"。
+ *
+ * 它本来就是**去 registry 问这个包**的那个人（安装前先 inspect），所以这条路
+ * 走的是应用自己那条网络出口、且尊重用户配的镜像源 —— 比我们自己去抓 packument
+ * 更接近"安装时会装到哪一版"。`web` 服务拿不到时，这是唯一还活着的更新通道。
+ *
+ * @returns `{ ok, version, registry }` 或 `{ ok: false, reason, detail }` — never throws.
+ */
+export async function readManagedVersion(ctx, name, timeoutMs) {
+  let manager
   try {
-    const declared = ctx && ctx.web
-    if (declared && typeof declared.fetch === 'function') return declared
-  } catch (error) { /* no such property */ }
-  return undefined
+    if (!ctx || typeof ctx.get !== 'function') return { ok: false, reason: 'no-ctx-get' }
+    manager = ctx.get('pluginManager')
+  } catch (error) {
+    return { ok: false, reason: 'manager-unreachable', detail: String(error && error.message ? error.message : error).slice(0, 80) }
+  }
+  if (!manager || typeof manager.inspect !== 'function') {
+    return { ok: false, reason: 'no-plugin-manager', detail: describeService(manager) }
+  }
+  try {
+    const info = await withTimeout(manager.inspect(name), timeoutMs)
+    if (info && info.status === 'accepted' && typeof info.version === 'string') {
+      return { ok: true, version: info.version, registry: info.registry ?? null }
+    }
+    return {
+      ok: false,
+      reason: 'inspect-refused',
+      detail: info && info.reason ? String(info.reason).slice(0, 100) : describeService(info),
+    }
+  } catch (error) {
+    return { ok: false, reason: 'inspect-failed', detail: String(error && error.message ? error.message : error).slice(0, 100) }
+  }
 }
 
 /**
@@ -84,7 +154,10 @@ export function resolveWebService(ctx) {
  * @returns `{ ok, version }` or `{ ok: false, reason }` — never throws.
  */
 export async function readVersion(web, url, signal) {
-  if (!web || typeof web.fetch !== 'function') return { ok: false, reason: 'no-web-service' }
+  if (!web) return { ok: false, reason: 'no-web-service' }
+  /* "有服务但没有 fetch"和"根本没有服务"是两件事 —— 台词的下一步动作不同
+     （一个是应用/平台的问题，一个是插件注入的问题），所以别合并成一句。 */
+  if (typeof web.fetch !== 'function') return { ok: false, reason: 'web-has-no-fetch', detail: describeService(web) }
   try {
     const res = await web.fetch({ url }, signal)
     if (!res || typeof res.statusCode !== 'number') return { ok: false, reason: 'bad-result' }
@@ -305,9 +378,38 @@ export function registerHandlers(ctx, options = {}) {
   const dispose = seat.handle('checkUpdate', async (args) => {
     const current = args && typeof args.current === 'string' ? args.current : null
     /* 服务**在调用时**解析，不用闭包里那个可能早就定格的 ctx.web（见 resolveWebService）。 */
-    const web = resolveWebService(ctx)
-    const verdict = await readPublishedVersion(web, urls, undefined, CHECK_TIMEOUT_MS)
-    return { ...verdict, current, checkedAt: new Date().toISOString() }
+    const resolved = resolveWebService(ctx)
+    if (resolved.service) {
+      const verdict = await readPublishedVersion(resolved.service, urls, undefined, CHECK_TIMEOUT_MS)
+      return { ...verdict, current, diag: { via: 'web', how: resolved.how, why: resolved.why }, checkedAt: new Date().toISOString() }
+    }
+    /* 没有可用的 web 服务时的兜底：问插件管理器"这个包现在是什么版本"。
+       它走的是应用自己那条网络出口（安装前就要去 registry 问），所以这条路
+       是"安装时会装到哪一版"的权威答案 —— 而且不依赖插件能否拿到 web。 */
+    const managed = await readManagedVersion(ctx, UPDATE_PACKAGE_NAME, CHECK_TIMEOUT_MS)
+    const sources = { npm: managed.ok
+      ? { ok: true, version: managed.version }
+      : { ok: false, reason: managed.reason, detail: managed.detail } }
+    if (managed.ok) {
+      return {
+        ok: true,
+        latest: managed.version,
+        from: 'npm',
+        sources,
+        current,
+        diag: { via: 'pluginManager', how: resolved.how, why: resolved.why, registry: managed.registry ?? null },
+        checkedAt: new Date().toISOString(),
+      }
+    }
+    sources.github = { ok: false, reason: 'no-web-service', detail: resolved.why }
+    return {
+      ok: false,
+      reason: 'no-web-service',
+      sources,
+      current,
+      diag: { via: 'none', how: resolved.how, why: resolved.why, manager: managed.reason + (managed.detail ? '：' + managed.detail : '') },
+      checkedAt: new Date().toISOString(),
+    }
   })
   /* The balance handler. `ctx.deepseekAccount` is undefined unless the platform
      provides it — readBalance() turns that into `no-account-service` rather than

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-wisp",
-  "version": "1.42.0",
+  "version": "1.44.0",
   "description": "DeepSeek娘 — an unofficial floating desktop companion for the DeepSeek Harness UI. Zero dependencies; sprites inlined as data URIs; schedules on the Client timer service instead of the trapped browser timer globals.",
   "type": "module",
   "main": "lib/index.js",