dsh-wisp 0.6.0 → 1.25.1

package/lib/client.template.js

@@ -43,16 +43,49 @@
    ========================================================================== */
 window.__ModuleLoader__.load({
   id: 'dsh-wisp/client',
-  factory: (require) => {
+  /* 参数故意不叫 `require`：客户端半包里 `require` 是**被陷阱的全局**（一调用就抛），
+     而构建守卫对源码做正则，无法区分"被陷阱的全局"与"遮蔽它的工厂参数"。叫
+     `loadModule` 让"这是模块系统的解析面"成为代码里看得见的事实，守卫也就能保持严格。 */
+  factory: (loadModule) => {
     var module = { exports: {} }
     var exports = module.exports
     Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 
-    const VERSION = '0.6.0'
+    const VERSION = '1.25.1'
+
+/* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
+   忘了更新就会红，不会静默过期。 */
+const WHATS_NEW = {
+  '1.16.0': '按社区规范换上鲸鳍耳。',
+  '1.17.0': '鳍耳缩小、加上呆毛。',
+  '1.18.0': '新增原版女仆的完整提示词。',
+  '1.20.0': '第五套皮肤「原版女仆」上线。',
+  '1.21.0': '去掉双马尾，五套皮肤统一长直发。',
+  '1.22.0': '生成审计日志：素材来源可自查。',
+  '1.23.0': '滚轮调大小、方向键挪位置、躲起来也能开菜单。',
+  '1.24.0': '她会报自己的版本，更新过会告诉你，还能把包名复制给你。',
+  '1.25.0': '她真的会去查有没有新版本了。',
+  '1.25.1': '内容与 1.25.0 相同，重新发布以修好安装源。',
+}
+
+/* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
+   宿主半包跑在 vm 沙箱里，harness 只给 { defineTool, registerTool, handle }，
+   沙箱里还有 nodeApiTraps() 挡着 Node API —— 没有网络、没有文件系统。
+   DSH 的插件安装器也没有以可注入服务的形式暴露出来。
+   所以这里只做三件真能做的事：报版本、说她更新了、把包名复制给你去 DSH 里装。 */
+const SEEN_VERSION_KEY = 'dsh-wisp:seen-version:v1'
+const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
 
     /* ---- sprites: 256x384 WebP, transparent, inlined by build.mjs ---- */
     const SPRITES = __SPRITES_LITERAL__
 
+    /* 皮肤显示名。没在这里登记的皮肤直接用它的目录名 —— 所以增删皮肤只需要
+       放素材 + 重新构建，不必改这一段。 */
+    const SKIN_LABELS = { deepsea: '深海女仆', canon: '原版女仆', classic: '素绘女仆', night: '宵蓝礼服', pajama: '宵眠睡衣', default: '默认' }
+    /* 皮肤 id 表放在模块级：mount 里恢复"上次选的皮肤"时就要用它，那时 mount
+       内部的 const 还没求值（写成 mount 内的 const 会踩 TDZ）。 */
+    const SKIN_IDS = Object.keys(SPRITES)
+
     /* ---------------------------------------------------------------------
        SPRITE URL RESOLUTION — why this is not simply `img.src = dataUri`.
 
@@ -113,6 +146,7 @@ window.__ModuleLoader__.load({
     const SAY_CLEARANCE = 84   // room the bubble needs above its anchor
     const POLL_MS = 1200       // reaction poll
     const WAKE_THROTTLE_MS = 1000
+    const WORRIED_MS = 3500                 // 出错表情持续多久
 
     const DEFAULTS = {
       bottom: GROUND,
@@ -124,23 +158,130 @@ window.__ModuleLoader__.load({
       celebrate: true,          // cheer when a run finishes
       celebrateAfterMs: 2500,   // ...but only for runs that lasted this long
       chatterMs: 0,             // 0 = she stays quiet when idle
+      careAfterMs: 5400000,     // 连续活动这么久之后提醒你起来动动（90 分钟；0 = 关）
+      milestones: true,         // 今日轮次到达里程碑时得意一下
+      memory: true,             // 她记着你：一起多少天 / 常放哪个角 / 常穿哪套
       happyMs: 1100,
       wander: true,             // stroll around on her own while idle
       wanderMs: 45000,          // how often she considers moving
       wanderRange: 260,         // furthest a single stroll may travel
+      skin: '',                 // '' = 上次选的那套；也可点名一套皮肤
+      hidden: false,            // true = 挂载时就是躲起来的状态（只能强制隐藏，恢复走菜单）
+      /* 让窗口的 DWM 背景材质（Mica/Acrylic）真正露出来：清掉"铺满视口的不透明底色"。
+         桌面窗口有两种"透"：
+           1) 整窗 alpha（SetLayeredWindowAttributes + LWA_ALPHA）—— 桌面不模糊地透过来，
+              但**窗内每一个像素**都被乘掉，包括她的精灵图，于是她跟着一起透；
+           2) DWM 背景材质（Mica/Acrylic）—— 只有窗口背景透，窗内内容保持不透明。
+         2 正是"壁纸可见 + 她实心"，但它要求页面在背景处不画不透明像素。
+         默认关：这是一处影响整个应用的视觉改动，不该由她替别人做主。 */
+      backdrop: false,
     }
 
+    /* ---------------------------------------------------------------------
+       台词表。
+
+       她是个"长期在场"的东西：一天点几十次、看几百轮任务。3–6 句的池子在一周内就会被
+       看穿，所以每个场景的池子都留得足够宽，且按**时段**分四套招呼语 —— 凌晨三点和上午
+       十点不该说同一句话。
+
+       语气基准：安静、干、偶尔自嘲，不谄媚也不聒噪；她和你并排坐着干活，不是客服。
+       --------------------------------------------------------------------- */
     const LINES = {
-      hello: ['我在这儿。', '灯亮着，你忙你的。', '需要我就戳一下。'],
-      click: ['嗯？', '在的。', '别戳啦。', '……痒。', '有事说，没事也成。', '我一直看着屏幕呢。'],
-      happy: ['叮——', '这个我喜欢。', '再来一次？'],
-      sleep: ['呼……', '我眯一会儿。'],
-      wake: ['醒了醒了。', '嗯，我在。'],
-      done: ['跑完了。', '收了。', '这一轮结束。', '去看看？'],
-      chatter: ['……', '有点安静。', '我在数窗外的光。'],
-      move: ['这儿也行。', '我挪个位置。', '让让，我站这儿。'],
-      home: ['回来了。', '还是老地方。', '嗯，归位。'],
+      hello: ['我在这儿。', '灯亮着，你忙你的。', '需要我就戳一下。', '我又来了。', '还在老位置。'],
+
+      // 招呼语按时段取，见下面的 greetPoolName()
+      morning: ['早上好。', '早，今天从哪儿开始？', '醒了？我比你先到。', '早上安静，适合干活。', '早上的脑子最好用，别浪费。'],
+      afternoon: ['下午了。', '这一下午还长着呢。', '午后最容易走神，我盯着你。', '下午的光比上午暖。', '喝口水吧，还早。'],
+      evening: ['到晚上了。', '天黑了，灯打开没？', '晚上的你和白天的你不太一样。', '入夜了，剩下的慢慢来。', '这个点最容易一口气干到天亮。'],
+      night: ['这么晚还在？', '夜深了，别硬撑。', '凌晨的屏幕最亮。', '我不催你，但我会记着时间。', '夜里的话少，正好干活。'],
+
+      click: [
+        '嗯？', '在的。', '别戳啦。', '……痒。', '有事说，没事也成。', '我一直看着屏幕呢。',
+        '你再戳一下我就不客气了。', '干嘛？', '在呢在呢。', '戳我一百下也不会多出一条信息。',
+        '手闲了？', '我在这儿待着挺好的。', '有点痒，但是不讨厌。', '你想说什么就说吧。',
+      ],
+      happy: [
+        '叮——', '这个我喜欢。', '再来一次？', '哦？', '难得。', '嗯，这算好事。', '记下了。',
+        '你心情不错。', '看得出来今天顺。',
+      ],
+      sleep: [
+        '呼……', '我眯一会儿。', '……先睡了。', '撑不住了，抱歉。', '有事叫我，我听得见。', '你忙，我躺会儿。',
+        '眼睛闭上了，耳朵还开着。', '别看我，我睡着了。',
+      ],
+      wake: [
+        '醒了醒了。', '嗯，我在。', '谁？……哦，是你。', '没睡着，只是闭着眼。', '来了。', '继续吧。',
+        '刚才梦到海了。', '一点动静就醒。',
+      ],
+      done: [
+        '跑完了。', '收了。', '这一轮结束。', '去看看？', '结束了，轮到你。', '干得不错。',
+        '这轮比上轮快。', '我数着步数呢，收工。', '好了，喘口气。', '结论在上面，自己看。',
+      ],
+      chatter: [
+        '……', '有点安静。', '我在数窗外的光。', '你打字的声音挺好听的。', '刚才那行删掉又打了一遍。',
+        '我不打扰你，就是想说句话。', '这个字你打错了三次。', '屏幕有点烫。', '你喝水了吗。',
+        '我在这儿看了很久了。',
+      ],
+      move: [
+        '这儿也行。', '我挪个位置。', '让让，我站这儿。', '换个角度。', '这边清楚点。', '不挡你吧？',
+        '挪好了。', '新位置，一样站得住。',
+      ],
+      home: [
+        '回来了。', '还是老地方。', '嗯，归位。', '兜一圈还是这儿最好。', '角落最省地方。', '站稳了。',
+        '老位置，踏实。', '就这儿吧。',
+      ],
+      error: [
+        '出错了。', '好像不太顺。', '这一下没成。', '要不要看一眼报错？', '红的。去看一眼。',
+        '这次不怪你……也不一定。', '停下来了，可能需要你。', '又来了，先别急。', '报错在下面。',
+      ],
+      attn: [
+        '有人在等你回答。', '这里需要你点一下。', '轮到你了。', '它停下来了，等你。', '别让它干等着。',
+        '要你拍板。', '你看一眼这里。', '这一步只有你能过。',
+      ],
+      poked: [
+        '等一下。', '别戳了别戳了。', '……你干嘛。', '我在这儿又不会跑。', '手拿开。', '再戳我就躲起来了。',
+        '有点过分了啊。', '戳坏了你赔。', '我抗议。', '停。',
+      ],
+      /* 久坐提醒：她是"盯着你干活"的那个，所以这件事本来就该由她说。 */
+      /* 今日轮次里程碑：台词里的 {n} 会被替换成实际轮数 */
+      /* 她记着的那些事。带 {n}/{c}/{s} 的占位符在说话时替换。 */
+      days: [
+        '我们一起 {n} 天了。', '第 {n} 天 —— 记着呢。', '{n} 天了，居然还在。', '今天是第 {n} 天。',
+      ],
+      habitCorner: [
+        '你总把我放在{c}。', '又是{c} —— 你习惯那儿了。', '{c} 都快成我的位置了。',
+      ],
+      habitSkin: [
+        '你最近常让我穿{s}。', '{s} —— 你好像挺喜欢这套。', '又是{s}，我都快忘了别的了。',
+      ],
+      /* 检查更新用的三句。前两句带结果，第三句是"查不了/没查成"。 */
+      updateCurrent: ['已经是最新的了。', '我就是最新的。', '没有更新的。'],
+      updateAvailable: ['有新版本了：', '有新版：', '更新来了：'],
+      updateFailed: ['更新没查成。', '这次没查到更新。', '更新检查没成功。'],
+      milestone: [
+        '今天第 {n} 轮了。', '{n} 轮了，还不错。', '已经 {n} 轮了，你挺能撑。',
+        '第 {n} 轮 —— 我数着呢。', '{n} 轮，进度可观。', '今天 {n} 轮，记上了。',
+        '第 {n} 轮，干得不错。', '{n} 轮了，比昨天多？',
+      ],
+      care: [
+        '你已经坐很久了。', '起来走两步吧，我不跑。', '水杯空了吧。', '眼睛也要休息。',
+        '我数着时间呢。', '站起来伸个懒腰。', '再坐下去腰会抗议的。', '别一坐就是一整天。',
+        '去窗边看看。', '我在这儿等你回来。', '坐太久了，动一下。', '你不动，我就一直看着你。',
+      ],
+      hint: ['右键我一下试试。', '右键我有菜单。', '拖我，或者右键我。'],
+    }
+
+    /* 时段划分：凌晨与白天说话的口气不一样。深夜跨了两天，所以按"< 5 点"算夜里。 */
+    const greetPoolName = (hour) => {
+      if (hour < 5 || hour >= 22) return 'night'
+      if (hour < 11) return 'morning'
+      if (hour < 18) return 'afternoon'
+      return 'evening'
+    }
+    const greetPool = (name) => (LINES[name] && LINES[name].length ? LINES[name] : LINES.hello)
+    const hourNow = () => {
+      try { return new Date().getHours() } catch (e) { return 12 }
     }
+
     const pick = (a) => a[Math.floor(Math.random() * a.length)]
     const clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v)
 
@@ -180,6 +321,9 @@ window.__ModuleLoader__.load({
       sleepAfterMs: { kind: 'num', lo: 5000, hi: 3600000 },
       celebrateAfterMs: { kind: 'num', lo: 0, hi: 600000 },
       chatterMs: { kind: 'num', lo: 0, hi: 3600000 },
+      careAfterMs: { kind: 'num', lo: 0, hi: 86400000 },
+      milestones: { kind: 'bool' },
+      memory: { kind: 'bool' },
       happyMs: { kind: 'num', lo: 200, hi: 10000 },
       wanderMs: { kind: 'num', lo: 5000, hi: 3600000 },
       wanderRange: { kind: 'num', lo: 0, hi: 2000 },
@@ -187,11 +331,16 @@ window.__ModuleLoader__.load({
       persist: { kind: 'bool' },
       celebrate: { kind: 'bool' },
       wander: { kind: 'bool' },
+      hidden: { kind: 'bool' },
+      backdrop: { kind: 'bool' },
+      skin: { kind: 'str' },
     }
 
     const coerce = (key, value, fallback) => {
       const spec = CONFIG_SPEC[key]
-      return spec.kind === 'num' ? num(value, spec.lo, spec.hi, fallback) : bool(value, fallback)
+      if (spec.kind === 'num') return num(value, spec.lo, spec.hi, fallback)
+      if (spec.kind === 'str') return typeof value === 'string' ? value : fallback
+      return bool(value, fallback)
     }
 
     const normalizeConfig = (config) => {
@@ -323,6 +472,10 @@ window.__ModuleLoader__.load({
        just means "no remembered position".
        --------------------------------------------------------------------- */
     const POSITION_KEY = 'dsh-wisp:position:v1'
+    const SKIN_KEY = 'dsh-wisp:skin:v1'
+    const HIDDEN_KEY = 'dsh-wisp:hidden:v1'
+    const PREFS_KEY = 'dsh-wisp:prefs:v1'
+    const HINT_KEY = 'dsh-wisp:hint:v1'
 
     const readStored = (key) => {
       try {
@@ -379,7 +532,23 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 .wisp-root[data-mood="sleep"] .wisp-img{filter:drop-shadow(0 6px 14px rgba(0,0,0,.25)) saturate(.82) brightness(.96)}
 @keyframes wisp-bob{0%{transform:translate3d(0,0,0)}50%{transform:translate3d(0,-9px,0)}100%{transform:translate3d(0,0,0)}}
 @keyframes wisp-zzz{0%{opacity:0;transform:translate(0,0) scale(.6)}30%{opacity:.9}100%{opacity:0;transform:translate(14px,-30px) scale(1.15)}}
+.wisp-root[data-mood="attn"]{--wisp-aura:rgba(255,138,120,.55)}
+.wisp-root[data-mood="worried"]{--wisp-aura:rgba(150,170,190,.5)}
+.wisp-root[data-mood="worried"] .wisp-img{filter:drop-shadow(0 6px 14px rgba(0,0,0,.25)) saturate(.86)}
+.wisp-root[data-mood="worried"] .wisp-body{animation-name:wisp-worry;animation-duration:2.4s;animation-iteration-count:3}
+@keyframes wisp-worry{0%,100%{transform:translate3d(0,0,0)}50%{transform:translate3d(0,-5px,0)}}
+.wisp-root[data-mood="attn"] .wisp-body{animation-name:wisp-nudge;animation-duration:1.5s;animation-iteration-count:4}
+@keyframes wisp-nudge{0%,100%{transform:translate3d(0,0,0)}25%{transform:translate3d(-7px,0,0)}75%{transform:translate3d(7px,0,0)}}
 @keyframes wisp-hop{0%,100%{transform:translate3d(0,0,0)}45%{transform:translate3d(0,-16px,0)}}
+.wisp-menu{position:absolute;min-width:150px;padding:5px;border-radius:11px;font-size:12px;line-height:1.2;color:var(--dsw-alias-label-primary,var(--wisp-say-fg));background:var(--dsw-alias-bg-overlay,var(--wisp-say-bg));border:1px solid var(--dsw-alias-border-l1,var(--wisp-say-line));box-shadow:0 10px 30px rgba(0,0,0,.28);-webkit-backdrop-filter:blur(14px) saturate(160%);backdrop-filter:blur(14px) saturate(160%);pointer-events:auto;animation:wisp-menu .14s ease}
+.wisp-menu-item{display:block;width:100%;padding:7px 10px;border:0;border-radius:7px;background:none;color:inherit;font:inherit;text-align:left;cursor:pointer;white-space:nowrap}
+.wisp-menu-item:hover{background:var(--dsw-alias-bg-layer-2,rgba(120,170,255,.22))}
+.wisp-menu-head{padding:7px 10px 3px;font-size:11px;opacity:.62;letter-spacing:.04em}
+.wisp-root[data-hidden="true"]{display:none}
+.wisp-tab{position:absolute;width:56px;height:56px;padding:0;display:flex;align-items:center;justify-content:center;overflow:hidden;border-radius:16px;border:1px solid var(--dsw-alias-border-l1,var(--wisp-say-line));background:var(--dsw-alias-bg-overlay,var(--wisp-say-bg));box-shadow:0 6px 18px rgba(0,0,0,.22);cursor:pointer;pointer-events:auto;animation:wisp-menu .16s ease;transition:transform .16s ease}
+.wisp-tab:hover{transform:translateY(-2px)}
+.wisp-tab img{width:100%;height:100%;object-fit:contain;object-position:bottom center;pointer-events:none}
+@keyframes wisp-menu{0%{opacity:0;transform:scale(.94)}100%{opacity:1;transform:scale(1)}}
 @keyframes wisp-say{0%{opacity:0;transform:translate(-50%,-100%) translateY(6px) scale(.94)}12%{opacity:1;transform:translate(-50%,-100%) translateY(0) scale(1)}82%{opacity:1;transform:translate(-50%,-100%) translateY(0) scale(1)}100%{opacity:0;transform:translate(-50%,-100%) translateY(-6px) scale(.98)}}
 @media (prefers-reduced-motion:reduce){.wisp-body{animation:none!important}}`
 
@@ -503,6 +672,56 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 
     const agentIsBusy = () => !!document.querySelector(STOP_SELECTOR)
 
+    /* ---------------------------------------------------------------------
+       "在等你动手" —— 三个面板各自用 data-* key 标注，语言无关：
+         [data-question-key]       Agent 提问了，等你回答
+         [data-plan-review-key]    计划待你确认
+         [data-approval-key]       工具授权待你批准
+       元素只在真的有待处理项时才渲染，所以"存在"本身就是信号；key 用来区分
+       "新的一件事" —— 同一件事不重复提醒，换了一件才再说一次。
+       --------------------------------------------------------------------- */
+    const PENDING_ATTRS = ['data-question-key', 'data-plan-review-key', 'data-approval-key']
+    const PENDING_SELECTOR = PENDING_ATTRS.map((a) => '[' + a + ']').join(',')
+
+    const readPending = () => {
+      let el = null
+      try { el = document.querySelector(PENDING_SELECTOR) } catch (e) { return null }
+      if (!el || typeof el.getAttribute !== 'function') return null
+      for (let i = 0; i < PENDING_ATTRS.length; i++) {
+        const value = el.getAttribute(PENDING_ATTRS[i])
+        if (value) return value
+      }
+      return 'pending'
+    }
+
+    /* ---------------------------------------------------------------------
+       出错的行。DSH 给失败的工具行与命令卡都标了 data-error="true"（ui-tool 的
+       ToolRow、ui-chat 的 GenericCommandCard），所以存在性就是信号。
+
+       但这是全文档扫描，不能放进每 1.2 秒的轮询里 —— 那会把"空闲时 0 次
+       querySelectorAll"的性能结论作废。只在"一轮刚跑完"的那一刻查一次：错误
+       只会出现在那个时刻，而且一轮一次，摊到整场会话可以忽略。
+       --------------------------------------------------------------------- */
+    const ERROR_SELECTOR = '[data-error="true"]'
+
+    /* 插件在这个页面里用到的主题令牌。doctor() 会把它们逐个读出来 —— 全为空说明
+       壳的主题层没起来，亮暗跟随会退化成默认色。 */
+    const THEME_TOKENS = [
+      '--dsw-alias-label-primary',
+      '--dsw-alias-bg-overlay',
+      '--dsw-alias-border-l1',
+      '--dsw-alias-bg-layer-2',
+      '--dsw-alias-brand-primary',
+    ]
+    const countErrors = () => {
+      try {
+        const found = document.querySelectorAll(ERROR_SELECTOR)
+        return found && typeof found.length === 'number' ? found.length : 0
+      } catch (e) {
+        return 0
+      }
+    }
+
     let composerEl = null
     let composerMisses = 0
 
@@ -528,9 +747,14 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 
     const mount = (config, ctx) => {
       const cfg = normalizeConfig(config)
+      /* 配置里"显式写了 size"与"用了默认值"必须区分开：前者该压过记忆里的尺寸，
+         后者不该 —— 否则用户在菜单里调好的大小会被默认值悄悄顶掉。 */
+      const sizeIsExplicit = !!config && typeof config === 'object'
+        && Object.prototype.hasOwnProperty.call(config, 'size') && config.size !== undefined
       const clock = createClock(ctx)
       const styleDispose = installStyles(ctx && typeof ctx.get === 'function' ? ctx.get('styles') : undefined)
 
+
       const vw = () => window.innerWidth || 1400
       const vh = () => window.innerHeight || 900
       /* The box she OCCUPIES is the base box times the render scale, and every
@@ -539,6 +763,117 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
          the wrong place — invisible at size 1, obvious at any other. */
       const boxW = () => BOX_W * cfg.size
       const boxH = () => BOX_H * cfg.size
+
+      /* ---------------------------------------------------------------------
+         让窗口的 DWM 背景材质露出来（cfg.backdrop，默认关）
+
+         "壁纸透过来"有两条完全不同的路：
+
+           1) 整窗 alpha —— SetLayeredWindowAttributes(hwnd, 0, alpha, LWA_ALPHA)。
+              桌面**不模糊**地透过来，因为它是把整窗表面乘一个系数再叠上去。
+              代价：窗内**每一个像素**都被乘掉 —— 包括她的精灵图，所以她会跟着一起透。
+              这是 `dsh-transparent` 的默认做法（alpha 默认 215）。
+
+           2) DWM 背景材质 —— DwmSetWindowAttribute(hwnd, 38, Mica|Acrylic)。
+              只有**窗口背景**是壁纸，窗内内容（文字、面板、她）保持不透明。
+              这正是"壁纸可见 + 她实心"，两条要求同时成立。
+
+         2 的唯一前提：页面在背景处**不画不透明像素**。若应用自己在整个视口上铺了一层底色，
+         Mica 就被整块挡住 —— 这时把那层底色清掉即可，Mica 自然露出来。
+
+         为什么由她来做这件事：她要的是"自己不受整窗 alpha 影响"，而唯一能同时满足
+         "壁纸可见"的机制就是 2；把 2 卡住的那层底色清掉，是她能自己完成的最小改动，
+         不需要去改另一个插件的任何一行。
+         --------------------------------------------------------------------- */
+      const BACKDROP_STYLE_ID = 'wisp-backdrop'
+
+      /* 只处理"铺满视口"的元素：采样点上最上面那个画底色的，且尺寸接近整个视口。
+         有尺寸下限，所以内容卡片、气泡、菜单都不会被误伤。 */
+      const findBackdropBlockers = () => {
+        const selectors = new Set()
+        const blockers = []
+        const skipped = []
+        const errors = []
+        const seenEls = new Set()
+        if (typeof document.elementsFromPoint !== 'function') return { selectors: [], blockers, skipped, errors }
+        const spots = [[0.5, 0.5], [0.2, 0.5], [0.8, 0.5], [0.5, 0.85]]
+        for (const [fx, fy] of spots) {
+          let stack = []
+          try { stack = document.elementsFromPoint(vw() * fx, vh() * fy) || [] } catch (e) { continue }
+          for (const el of stack) {
+            if (!el || el === document.documentElement || el === document.body) continue
+            if (seenEls.has(el)) continue          // 同一个元素会在多个采样点上出现，只记一次
+            seenEls.add(el)
+            let bg
+            let rect
+            try {
+              bg = window.getComputedStyle(el).backgroundColor
+              rect = el.getBoundingClientRect()
+            } catch (e) { continue }
+            if (!bg || bg === 'transparent' || bg === 'rgba(0, 0, 0, 0)') continue
+            if (rect.width < vw() * 0.8 || rect.height < vh() * 0.3) continue
+            blockers.push({ background: bg, size: Math.round(rect.width) + 'x' + Math.round(rect.height) })
+            /* 类名要能安全地写进选择器：带数字开头的哈希类名（CSS 里得转义）直接跳过，
+               宁可漏掉一层也不要写出无效规则把整张样式表毁掉。 */
+            const cls = String(el.className || '').split(/\s+/).filter(Boolean)[0]
+            if (cls && /^-?[_a-zA-Z][-_a-zA-Z0-9]*$/.test(cls)) selectors.add(cls)
+            else if (cls) skipped.push(cls)
+            break          // 只看每个采样点上最上面那一层
+          }
+        }
+        return { selectors: [...selectors], blockers, skipped, errors }
+      }
+
+      const removeBackdropStyle = () => {
+        try {
+          const tag = document.getElementById(BACKDROP_STYLE_ID)
+          if (tag && tag.parentNode) tag.parentNode.removeChild(tag)
+        } catch (e) { /* ignore */ }
+      }
+
+      const applyBackdrop = () => {
+        const report = { enabled: !!cfg.backdrop, cleared: [], blockers: [], skipped: [], errors: [] }
+        /* 关掉开关要把已经注入的规则收回 —— 否则"关掉"只是不再新增，页面上还留着上一次的改动。 */
+        if (!report.enabled) { removeBackdropStyle(); return report }
+        const found = findBackdropBlockers()
+        report.blockers = found.blockers
+        report.skipped = found.skipped
+        report.errors = found.errors
+        /* 只在开关打开时打一行：这个功能的成败取决于"页面上到底有没有挡路的底色"，
+           而那件事只有页面自己知道 —— 说出来，否则"壁纸没回来"就无从判断是哪一步没成。 */
+        if (typeof console !== 'undefined' && console.log) {
+          console.log('[wisp] backdrop: ' + (found.selectors.length
+            ? '清掉 ' + found.selectors.length + ' 层铺满视口的底色 ' + JSON.stringify(found.selectors)
+              + (found.blockers[0] ? '（原色 ' + found.blockers[0].background + '）' : '')
+            : '没找到铺满视口的不透明底色 —— 挡路的另有其人，或 Mica 本身不生效')
+            + (found.errors.length ? '；扫描报错 ' + JSON.stringify(found.errors) : ''))
+        }
+        if (found.selectors.length === 0) return report
+        const css = found.selectors
+          .map((c) => '.' + c + '{background-color:transparent !important;background-image:none !important}')
+          .join('')
+        let tag = document.getElementById(BACKDROP_STYLE_ID)
+        if (!tag) {
+          tag = document.createElement('style')
+          tag.id = BACKDROP_STYLE_ID
+          document.head.appendChild(tag)
+        }
+        tag.textContent = css
+        report.cleared = found.selectors
+        return report
+      }
+      let backdropReport = applyBackdrop()
+
+      /* 菜单里调过的大小要活过刷新 —— 位置/皮肤/隐藏都记了，尺寸没记会显得前后
+         不一致。但配置里显式写了 size 时以配置为准（那是项目级的设定，比一次
+         临时缩放更权威）。 */
+      if (!sizeIsExplicit && cfg.persist) {
+        const prefs = readStored(PREFS_KEY)
+        if (prefs && typeof prefs.size === 'number' && isFinite(prefs.size)) {
+          cfg.size = num(prefs.size, CONFIG_SPEC.size.lo, CONFIG_SPEC.size.hi, cfg.size)
+        }
+      }
+
       const maxX = () => Math.max(0, vw() - boxW())
       const maxY = () => Math.max(0, vh() - boxH())
       const halfSay = () => Math.min(SAY_MAX_W / 2, Math.max(0, (vw() - 20) / 2))
@@ -580,6 +915,13 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         coords.y = clamp(vh() - cfg.bottom - boxH(), 0, maxY())
       }
 
+      /* 皮肤：优先用配置里点名的（必须存在），否则用上次选的，再否则用第一套。
+         记忆的皮肤名可能属于一个已经不再随包发布的皮肤，所以必须校验。 */
+      const storedSkin = cfg.persist ? readStored(SKIN_KEY) : null
+      let activeSkin = SKIN_IDS[0]
+      if (typeof cfg.skin === 'string' && SKIN_IDS.indexOf(cfg.skin) >= 0) activeSkin = cfg.skin
+      else if (storedSkin && typeof storedSkin.id === 'string' && SKIN_IDS.indexOf(storedSkin.id) >= 0) activeSkin = storedSkin.id
+
       /* The root is LAID OUT at its final size rather than transform-scaled:
          a scaled layer is rasterized once and then stretched, so an enlarged
          sprite goes soft, whereas a laid-out box rasterizes the 512px source at
@@ -626,8 +968,13 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       bodyEl.style.bottom = '0'
       bodyEl.style.pointerEvents = 'auto'
       bodyEl.setAttribute('role', 'button')
-      bodyEl.setAttribute('tabindex', '-1')
+      /* tabindex 是 0 而不是 -1：菜单已经支持键盘导航（↑↓/Home/End/Esc），但如果她本身
+         不可聚焦，键盘用户就**没有办法打开它** —— 声明了 role="menu" 却没有入口，与
+         "声明了 role 却按不动"是同一类问题。她挂在 body 末尾，所以 Tab 顺序上排在应用
+         内容之后，不会插队。 */
+      bodyEl.setAttribute('tabindex', '0')
       bodyEl.setAttribute('aria-label', 'DeepSeek娘')
+      bodyEl.setAttribute('aria-haspopup', 'menu')
 
       const shine = document.createElement('div')
       shine.className = 'wisp-shine'
@@ -648,10 +995,20 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (typeof console !== 'undefined' && console.error) console.error('[wisp] sprite failed to load')
       }
       let currentSprite = 'idle'
+      /* 皮肤：一套完整的 idle/happy/sleepy/work。activeSkin 随配置与记忆恢复，
+         切换时只需要重建精灵图与命中蒙版，位置和状态都不动。 */
+      /* 一套皮肤若不包含某个情绪（例如将来只给了四张），退到备选而不是空白 */
+      const spriteOf = (key) => {
+        const skin = SPRITES[activeSkin]
+        if (skin && typeof skin[key] === 'string') return skin[key]
+        const alt = SPRITE_FALLBACK[key]
+        if (alt && typeof skin[alt] === 'string') return skin[alt]
+        return skin.idle
+      }
 
       const setSprite = (key) => {
-        const url = resolveSprite(SPRITES[key])
-        buildMask(key, url)
+        const url = resolveSprite(spriteOf(key))
+        buildMask(activeSkin + '/' + key, url)
         currentSprite = key
         /* Cross-fade rather than swapping `src` outright: a hard swap makes every
            mood change read as a glitch. The outgoing sprite keeps its own layer
@@ -705,14 +1062,43 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           else if (console && console.error) console.error('[wisp] document.body never appeared')
           return
         }
+        /* 挂载前先清掉页面上任何**残留的旧层**。
+           只靠 `window.__wisp` 那一个句柄是不够的：那个引用可能属于另一个上下文/另一次加载，
+           于是旧层留在页面上、新层再叠一层 —— 表现就是"出现了两个她"。
+           她只有一个，这件事不该依赖任何一本书里记着的引用。 */
+        try {
+          const strays = document.querySelectorAll('.wisp-layer')
+          for (let i = 0; i < strays.length; i++) {
+            const el = strays[i]
+            if (el && el !== layer && el.parentNode) el.parentNode.removeChild(el)
+          }
+        } catch (e) { /* 清不掉也不该挡住挂载 */ }
         document.body.appendChild(layer)
         attached = true
       }
 
-      /* ---- mood -> sprite ---- */
-      const SPRITE_OF = { idle: 'idle', alert: 'work', happy: 'happy', sleep: 'sleepy' }
+      /* ---- mood -> sprite ----
+         attn 曾借用 work 那张，现在有自己的一张（抬手招你过来的姿态）。
+         仍然保留回退：某一套皮肤将来若没有 attn，她会退回 work，而不是变成空白。 */
+      const SPRITE_OF = { idle: 'idle', alert: 'work', happy: 'happy', sleep: 'sleepy', attn: 'attn', care: 'attn', poked: 'poked', proud: 'proud', worried: 'sleepy' }
+      const SPRITE_FALLBACK = { attn: 'work' }
       let mood = 'idle'
 
+      /* 换皮肤 = 换一整套精灵图。位置、情绪、气泡都不动，只有图与命中蒙版重建。 */
+      const skinLabel = (id) => SKIN_LABELS[id] ?? id
+      const applySkin = (id) => {
+        if (destroyed || typeof id !== 'string') return false
+        if (SKIN_IDS.indexOf(id) < 0) return false      // 不认识的名字就当作没这回事
+        const changed = id !== activeSkin
+        /* 只有**换到不同**的一套才算一次使用：初始皮肤是直接赋值进来的，不走这个函数；
+           setSkin 传同一个 id 也不该计数。（这里用 changed —— 别再写一个不存在的变量名。） */
+        if (changed) bump(memory.skins, id)
+        activeSkin = id
+        writeStored(SKIN_KEY, { id })
+        if (changed) setSprite(SPRITE_OF[mood])
+        return true
+      }
+
       const setMood = (next) => {
         if (destroyed || mood === next) return
         mood = next
@@ -729,6 +1115,14 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         }
       }
 
+      /* 气泡也挂在 layer 上，所以躲起来时必须单独收掉 —— 只把 root 设成
+         display:none 的话，会留下一个悬空的气泡在屏幕上。 */
+      const clearSay = () => {
+        if (sayHandle) { clock.cancel(sayHandle); sayHandle = null }
+        if (sayEl !== null && sayEl.parentNode) sayEl.remove()
+        sayEl = null
+      }
+
       let sayHandle = null
       const say = (text) => {
         if (destroyed) return
@@ -797,10 +1191,129 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         } catch (e) { offTheme = null }
       }
 
+      /* ---- 今日轮次：里程碑 --------------------------------------------------
+         她数的是"今天跑完多少轮"，所以要跨刷新记住。按天存：换了一天就归零，
+         但**记过的里程碑也要一起存** —— 否则同一天里刷新页面会把 10、25 又说一遍。
+         这里用真实日期（new Date()）而不是插件时钟：问的是"今天"，不是"这次页面开了多久"。 */
+      const RUNS_KEY = 'dsh-wisp:runs:v1'
+      const MILESTONES = [10, 25, 50, 100, 200, 500]
+      const dayKey = () => {
+        try {
+          const d = new Date()
+          return d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate()
+        } catch (e) { return 'unknown' }
+      }
+      let runsToday = (() => {
+        const stored = readStored(RUNS_KEY)
+        const today = dayKey()
+        if (stored && typeof stored === 'object' && stored.day === today && typeof stored.count === 'number') {
+          return { day: today, count: stored.count, said: Array.isArray(stored.said) ? stored.said : [] }
+        }
+        return { day: today, count: 0, said: [] }
+      })()
+
+      /* ---- 她记着你 --------------------------------------------------------
+         存的是"一起多少天 / 常放哪个角 / 常穿哪套"，以及**已经说过哪些**。
+         两条防噪规则是有意的：
+           1) 同一条记忆一辈子只说一次（said 里记着）；
+           2) 一天最多说一句（remarkDay）。
+         没有这两条，这些台词会在每次刷新时重复出现，很快就会从"她记得"变成"她唠叨"。 */
+      const MEMORY_KEY = 'dsh-wisp:memory:v1'
+      const MEMORY_MAX_DAYS = 90          // 别让这个记录无限长下去
+      const DAY_MILESTONES = [2, 7, 14, 30, 100]
+      const HABIT_MIN = 8                 // 一个角落至少用过这么多次才算"习惯"
+      const HABIT_SHARE = 0.6             // 而且要占大多数
+      const SKIN_MIN = 6
+
+      const memory = (() => {
+        const stored = readStored(MEMORY_KEY)
+        const mem = stored && typeof stored === 'object' ? stored : {}
+        const today = dayKey()
+        const days = Array.isArray(mem.days) ? mem.days.filter((d) => typeof d === 'string') : []
+        if (days.indexOf(today) < 0) days.push(today)
+        return {
+          days: days.slice(-MEMORY_MAX_DAYS),
+          corners: mem.corners && typeof mem.corners === 'object' ? mem.corners : {},
+          skins: mem.skins && typeof mem.skins === 'object' ? mem.skins : {},
+          said: Array.isArray(mem.said) ? mem.said : [],
+          remarkDay: typeof mem.remarkDay === 'string' ? mem.remarkDay : '',
+        }
+      })()
+      const saveMemory = () => writeStored(MEMORY_KEY, memory)
+      saveMemory()                        // 今天来过了，先记上
+
+      const bump = (bag, key) => {
+        if (typeof key !== 'string' || key === '') return
+        bag[key] = (typeof bag[key] === 'number' ? bag[key] : 0) + 1
+        saveMemory()
+      }
+      const topOf = (bag) => {
+        let best = null
+        let total = 0
+        for (const key of Object.keys(bag)) {
+          const n = bag[key]
+          if (typeof n !== 'number') continue
+          total += n
+          if (best === null || n > best.count) best = { key, count: n }
+        }
+        return best === null ? null : { key: best.key, count: best.count, total }
+      }
+
+      /* 挑一句"她记着的事"。返回 null 表示今天不该说。 */
+      const memoryRemark = () => {
+        if (!cfg.memory) return null
+        const today = dayKey()
+        if (memory.remarkDay === today) return null
+        const once = (key) => memory.said.indexOf(key) < 0
+        const claim = (key) => { memory.said.push(key); memory.remarkDay = today; saveMemory() }
+
+        if (DAY_MILESTONES.indexOf(memory.days.length) >= 0 && once('days:' + memory.days.length)) {
+          claim('days:' + memory.days.length)
+          return { mood: 'happy', text: pick(LINES.days).split('{n}').join(String(memory.days.length)) }
+        }
+        const corner = topOf(memory.corners)
+        if (corner && corner.count >= HABIT_MIN && corner.count / corner.total >= HABIT_SHARE && once('corner:' + corner.key)) {
+          claim('corner:' + corner.key)
+          return { mood: 'proud', text: pick(LINES.habitCorner).split('{c}').join(corner.key) }
+        }
+        const skin = topOf(memory.skins)
+        if (skin && skin.count >= SKIN_MIN && skin.key !== activeSkin && once('skin:' + skin.key)) {
+          claim('skin:' + skin.key)
+          return { mood: 'proud', text: pick(LINES.habitSkin).split('{s}').join(skinLabel(skin.key)) }
+        }
+        return null
+      }
+
       /* ---- react to what the app is doing ---- */
       let lastBusy = false
+      let lastPending = null
       let busySince = 0
+      /* 久坐追踪：activeSince = 这一段"坐在电脑前"的起点；0 表示不在这一段里。
+         CARE_ACTIVE_GAP_MS = 中间停顿多久算离开。 */
+      const CARE_ACTIVE_GAP_MS = 90000
+      let activeSince = 0
+      let lastActiveAt = 0
+      let lastCareAt = 0
       let happyHandle = null
+      let lastErrorCount = 0
+
+      const flashProud = (text) => {
+        setMood('proud')
+        say(text)
+        if (proudHandle) clock.cancel(proudHandle)
+        proudHandle = clock.after(PROUD_MS, () => { if (mood === 'proud') setMood('idle') })
+      }
+
+      /* 记一轮完成；命中里程碑时返回那个数字，否则 null */
+      const recordRun = () => {
+        const today = dayKey()
+        if (runsToday.day !== today) runsToday = { day: today, count: 0, said: [] }
+        runsToday.count++
+        const hit = MILESTONES.find((m) => m === runsToday.count && runsToday.said.indexOf(m) < 0)
+        if (hit !== undefined) runsToday.said.push(hit)
+        writeStored(RUNS_KEY, { day: runsToday.day, count: runsToday.count, said: runsToday.said })
+        return hit === undefined ? null : hit
+      }
 
       const flashHappy = (text) => {
         setMood('happy')
@@ -809,18 +1322,110 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         happyHandle = clock.after(cfg.happyMs, () => { if (mood === 'happy') setMood('idle') })
       }
 
+      /* 连戳到一定程度就换成"抗议"。它和 happy 一样是**瞬时状态**，但必须自己一份定时器：
+         否则同一轮询里的 idle/alert 会把它盖掉 —— worried 当初就是这么坏的。 */
+      const POKED_MS = 1800
+      let pokedHandle = null
+      const flashPoked = (text) => {
+        setMood('poked')
+        say(text)
+        if (pokedHandle) clock.cancel(pokedHandle)
+        pokedHandle = clock.after(POKED_MS, () => { if (mood === 'poked') setMood('idle') })
+      }
+
+      /* 久坐提醒用的也是一个**瞬时状态**（借 attn 的姿态），理由和 poked 一样：
+         稳态逻辑每轮都会重算，不给它自己的定时器就会被抹掉。 */
+      const PROUD_MS = 2800
+      let proudHandle = null
+
+      const CARE_MS = 4200
+      let careHandle = null
+      const flashCare = (text) => {
+        setMood('care')
+        say(text)
+        if (careHandle) clock.cancel(careHandle)
+        careHandle = clock.after(CARE_MS, () => { if (mood === 'care') setMood('idle') })
+      }
+
+      let worriedHandle = null
+      const flashWorried = (text) => {
+        setMood('worried')
+        say(text)
+        if (worriedHandle) clock.cancel(worriedHandle)
+        worriedHandle = clock.after(WORRIED_MS, () => { if (mood === 'worried') setMood('idle') })
+      }
+
+      /* 一轮刚跑完的那一刻看一次错误。同一批错误只说一次；错误清掉之后再出现新的
+         才会再说 —— 否则每轮结束都会重复念同一句。 */
+      const checkErrors = () => {
+        if (!cfg.reactions) return
+        const count = countErrors()
+        if (count > 0 && count !== lastErrorCount) flashWorried(pick(LINES.error))
+        lastErrorCount = count
+      }
+
       const poll = () => {
         if (destroyed) return
         let busy = false
         try { busy = agentIsBusy() } catch (e) { busy = false }
         if (busy && !lastBusy) busySince = nowMs()
-        if (!busy && lastBusy && cfg.celebrate && nowMs() - busySince >= cfg.celebrateAfterMs) {
-          flashHappy(pick(LINES.done))
+        if (!busy && lastBusy) {
+          /* 里程碑优先于普通庆祝：同一次跑完只该说一句，而"第 25 轮"比"跑完了"更值得说 */
+          const hit = cfg.reactions && cfg.milestones ? recordRun() : null
+          if (hit !== null) {
+            flashProud(pick(LINES.milestone).split('{n}').join(String(hit)))
+          } else if (cfg.celebrate && nowMs() - busySince >= cfg.celebrateAfterMs) {
+            flashHappy(pick(LINES.done))
+          }
+          // 一轮结束 = 错误唯一会出现的时机，所以错误检查挂在这个边上而不是轮询里
+          checkErrors()
         }
         lastBusy = busy
-        if (mood === 'sleep' || mood === 'happy') return
+
+        /* ---- 久坐追踪 ---------------------------------------------------------
+           "连着坐了多久"没有直接信号，用"最近有没有活动"近似：跑着任务或输入框里有字
+           就算还在动。中间短暂停一下（不到 CARE_ACTIVE_GAP_MS）不算离开 —— 人是会停下来
+           想事情的，把那种间隙当成"离开"会让计时永远攒不满。
+           判定放在这里（而不是稳态赋值之后）：瞬时的表情可能提前 return，而计时必须每轮都走。 */
         let typing = false
         try { typing = composerHasText() } catch (e) { typing = false }
+        const activeNow = busy || typing
+        const nowTick = nowMs()
+        if (activeNow) {
+          if (activeSince === 0) activeSince = nowTick
+          lastActiveAt = nowTick
+        } else if (activeSince !== 0 && nowTick - lastActiveAt > CARE_ACTIVE_GAP_MS) {
+          activeSince = 0                     // 他离开了一阵，这一段结束
+        }
+        if (
+          cfg.careAfterMs > 0 && activeSince !== 0
+          && nowTick - activeSince >= cfg.careAfterMs
+          && nowTick - lastCareAt >= cfg.careAfterMs
+        ) {
+          lastCareAt = nowTick
+          /* 提醒你的时候她自己得先醒着 —— 打盹着喊人起来活动，读起来像 bug。
+             pending 面板那条路也是这么处理的（先 wake 再说话）。 */
+          if (mood === 'sleep') wake(true)
+          flashCare(pick(LINES.care))
+        }
+
+        // 有东西在等她处理时，优先级高于一切：这是唯一"你不理它就卡住"的状态。
+        const pending = cfg.reactions ? readPending() : null
+        if (pending === null) {
+          lastPending = null
+        } else if (pending !== lastPending) {
+          lastPending = pending
+          if (mood === 'sleep') wake(true)     // 睡着了也要叫起来
+          say(pick(LINES.attn))
+        }
+        if (pending !== null) {
+          setMood('attn')
+          return
+        }
+
+        // 临时状态（happy / worried）在自己的计时器到期前不能被稳态赋值覆盖 ——
+        // 否则刚摆出的表情在同一个 poll 周期里就被 setMood('idle') 抹掉了。
+        if (mood === 'sleep' || mood === 'happy' || mood === 'poked' || mood === 'proud' || mood === 'care' || mood === 'worried') return
         setMood((busy || typing) ? 'alert' : 'idle')
       }
 
@@ -867,7 +1472,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (wanderHandle) { clock.cancel(wanderHandle); wanderHandle = null }
         if (!cfg.wander || cfg.wanderRange <= 0) return
         wanderHandle = clock.every(cfg.wanderMs, () => {
-          if (destroyed || mood !== 'idle' || start !== null) return
+          if (destroyed || hidden || mood !== 'idle' || start !== null) return
           if (agentIsBusy()) return
           // A random bearing with a floor on the distance, so a stroll is always
           // a real stroll rather than a rounding error in a random direction.
@@ -882,8 +1487,67 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       }
       syncWander()
 
+      /* ---- 躲起来 / 叫回来 ----
+         她放大到 560x840 之后会挡住会话和输入框，而"让她消失一会儿"原先只能整个
+         禁用插件。躲起来时留一个迷你按钮（用的是当前皮肤的 idle 图，所以不需要
+         额外素材），点一下就回来。状态记在本地，刷新后仍然躲着。 */
+      let hidden = cfg.hidden === true || (cfg.persist && readStored(HIDDEN_KEY)?.hidden === true)
+      root.dataset.hidden = hidden ? 'true' : 'false'
+      let tabEl = null
+
+      const hideTab = () => {
+        if (tabEl && tabEl.parentNode) tabEl.parentNode.removeChild(tabEl)
+        tabEl = null
+      }
+
+      const showTab = () => {
+        if (destroyed || tabEl !== null) return
+        const tab = document.createElement('button')
+        tab.className = 'wisp-tab'
+        tab.setAttribute('type', 'button')
+        tab.setAttribute('title', '把' + '她' + '叫回来')
+        tab.setAttribute('aria-label', '把 DeepSeek娘 叫回来')
+        tab.style.position = 'absolute'
+        tab.style.right = Math.round(cfg.right) + 'px'
+        tab.style.bottom = Math.round(cfg.bottom + 40) + 'px'
+        const thumb = document.createElement('img')
+        thumb.className = 'wisp-tab-thumb'
+        thumb.setAttribute('src', resolveSprite(spriteOf('idle')))
+        thumb.setAttribute('alt', '')
+        thumb.setAttribute('draggable', 'false')
+        tab.appendChild(thumb)
+        tab.addEventListener('pointerdown', (ev) => ev.stopPropagation())
+        tab.addEventListener('click', (ev) => {
+          ev.preventDefault(); ev.stopPropagation()
+          setHidden(false)
+        })
+        /* 躲起来之后，原先只能靠那个小按钮把她叫回来 —— 换皮肤、调大小、换角落在那个状态下
+           全都够不着。右键它直接开同一个菜单，这里就补上了。
+           （openMenu 在下面才定义；showTab 只在挂载完成之后的用户操作里跑，所以不是 TDZ。） */
+        tab.addEventListener('contextmenu', (ev) => {
+          ev.preventDefault(); ev.stopPropagation()
+          openMenu(ev.clientX ?? 0, ev.clientY ?? 0)
+        })
+        layer.appendChild(tab)
+        tabEl = tab
+      }
+
+      const setHidden = (next) => {
+        if (destroyed) return
+        hidden = next === true
+        root.dataset.hidden = hidden ? 'true' : 'false'
+        if (hidden) { closeMenu(); hideTab(); clearSay(); showTab() }
+        else { hideTab(); paint() }
+        if (cfg.persist) writeStored(HIDDEN_KEY, { hidden })
+      }
+
       /* ---- drag & click ---- */
       let start = null, origin = null, moved = false, lastClick = 0
+      /* 连戳计数：POKE_WINDOW_MS 内累计到 POKE_ANNOYED_AT 次就抗议一次 */
+      const POKE_WINDOW_MS = 3000
+      const POKE_ANNOYED_AT = 3
+      let pokeStreak = 0
+      let pokeWindowStart = 0
 
       const rememberPosition = () => {
         if (!cfg.persist) return
@@ -892,7 +1556,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 
       /** Whether this pointer is over an opaque pixel of the current sprite. */
       const hitsBody = (e) => {
-        const mask = masks[currentSprite]
+        const mask = masks[activeSkin + '/' + currentSprite]
         if (!mask) return true            // no mask yet: stay grabbable rather than vanish
         const boxw = boxW()
         const boxh = boxH()
@@ -926,11 +1590,22 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           return
         }
         if (destroyed) return
-        const now = Date.now()
+        /* 用 nowMs()（插件自己的时钟）而不是 Date.now()：双击窗口与连戳窗口必须和其他
+           有时间意义的行为共用同一个时钟，否则测试没法推进它，行为也无法在虚拟时间下复现。 */
+        const now = nowMs()
         const dbl = now - lastClick < 420
         lastClick = now
+        /* 连戳升级：短窗口内戳到第三次，她从"开心"转成"抗议"。
+           计数在窗口过期后归零 —— 隔一会儿再戳一下不该被记仇。 */
+        if (now - pokeWindowStart > POKE_WINDOW_MS) { pokeWindowStart = now; pokeStreak = 0 }
+        pokeStreak++
         wake(true)
-        flashHappy(dbl ? pick(LINES.happy) : pick(LINES.click))
+        if (pokeStreak >= POKE_ANNOYED_AT) {
+          pokeStreak = 0
+          flashPoked(pick(LINES.poked))
+        } else {
+          flashHappy(dbl ? pick(LINES.happy) : pick(LINES.click))
+        }
       }
       const onDown = (e) => {
         if (e.button !== 0) return
@@ -950,21 +1625,253 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       }
       bodyEl.addEventListener('pointerdown', onDown)
 
+      /* 键盘入口：Enter / Space / 菜单键 / Shift+F10 打开菜单。
+         Space 默认会滚动页面，Enter 在表单里会提交 —— 都要拦。 */
+      /* 方向键微调位置。
+         在这之前，**挪动她只能靠鼠标拖** —— 键盘用户拿到焦点后除了开菜单什么也做不了。
+         方向键是这类「可拖动物件」的通行补法（与拖动共用同一套边界夹紧与位置持久化）。
+         Shift = 细调；默认步长 16px，因为 1px 要按十几次才看得出动。 */
+      const NUDGE = 16
+      const NUDGE_FINE = 4
+      const NUDGE_KEYS = {
+        ArrowLeft: [-1, 0], ArrowRight: [1, 0], ArrowUp: [0, -1], ArrowDown: [0, 1],
+      }
+
+      const onBodyKey = (ev) => {
+        const nudge = NUDGE_KEYS[ev.key]
+        if (nudge) {
+          /* 不拦的话，方向键会同时把页面滚走 —— 那时候她看起来像是「跑掉了」。 */
+          if (typeof ev.preventDefault === 'function') ev.preventDefault()
+          if (typeof ev.stopPropagation === 'function') ev.stopPropagation()
+          const step = ev.shiftKey ? NUDGE_FINE : NUDGE
+          coords.x = clamp(coords.x + nudge[0] * step, 0, maxX())
+          coords.y = clamp(coords.y + nudge[1] * step, 0, maxY())
+          paint()
+          rememberPosition()
+          return
+        }
+        const opensMenu = ev.key === 'Enter' || ev.key === ' ' || ev.key === 'Spacebar'
+          || ev.key === 'ContextMenu' || (ev.shiftKey && ev.key === 'F10')
+        if (!opensMenu) return
+        if (typeof ev.preventDefault === 'function') ev.preventDefault()
+        if (typeof ev.stopPropagation === 'function') ev.stopPropagation()
+        openMenu(coords.x + boxW() / 2, coords.y + Math.min(boxH() / 2, 320))
+      }
+      bodyEl.addEventListener('keydown', onBodyKey)
+
+      /* ---- Ctrl/⌘ + 滚轮 = 调大小 ----
+         只认**带修饰键**的滚轮：她占地不小，直接吞掉普通滚轮等于在她身上把页面滚动禁掉。
+         带修饰键是「缩放」的通行手势，此时 preventDefault 才是帮忙而不是捣乱。
+         步长 0.25，上下限由 CONFIG_SPEC 统一夹紧（0.4–8），不在这里再写一遍。 */
+      const WHEEL_STEP = 0.25
+      const onWheel = (ev) => {
+        if (!ev.ctrlKey && !ev.metaKey) return          // 普通滚轮原样放行
+        if (typeof ev.preventDefault === 'function') ev.preventDefault()
+        if (typeof ev.stopPropagation === 'function') ev.stopPropagation()
+        const dir = (ev.deltaY ?? 0) < 0 ? 1 : -1       // 向上 = 变大，与浏览器缩放同向
+        applyConfig({ size: cfg.size + dir * WHEEL_STEP })
+      }
+      bodyEl.addEventListener('wheel', onWheel)
+
       /* ---- 右键 = 叫回原位 ----
          她大了之后很容易被拖到看不见的地方，而"恢复位置"原先只能开 Console。
-         右键她本体即可归位。 */
-      const onContext = (e) => {
-        if (!hitsBody(e)) return
-        e.preventDefault(); e.stopPropagation()
-        stopGlide()
-        // 默认落点（右下角），并把记忆的位置一起抹掉，避免下次刷新又跑回去
-        try { window.localStorage.removeItem(POSITION_KEY) } catch (err) { /* 存储不可用 */ }
-        coords.x = clamp(vw() - cfg.right - boxW(), 0, maxX())
-        coords.y = clamp(vh() - cfg.bottom - boxH(), 0, maxY())
+         现在右键她本体弹出菜单，归位只是其中一项。 */
+      const MENU_W = 158
+      const MENU_ITEM_H = 30
+      const MENU_PAD = 10
+      let menuEl = null
+      let menuOff = null
+
+      const closeMenu = () => {
+        if (menuEl && menuEl.parentNode) menuEl.parentNode.removeChild(menuEl)
+        menuEl = null
+        menuButtons = []
+        menuFocusAt = -1
+        if (menuOff) { menuOff(); menuOff = null }
+      }
+
+      /* 四个角落。她放大到 560x840 之后，"右下角"未必就是合适的位置 —— 屏幕右边
+         可能是侧栏，左下角未必被输入框挡住。 */
+      const CORNERS = [
+        { label: '右上角', at: (w, h, bw, bh, c) => ({ x: clamp(w - c.right - bw, 0, Math.max(0, w - bw)), y: clamp(c.bottom, 0, Math.max(0, h - bh)) }) },
+        { label: '左上角', at: (w, h, bw, bh, c) => ({ x: clamp(c.right, 0, Math.max(0, w - bw)), y: clamp(c.bottom, 0, Math.max(0, h - bh)) }) },
+        { label: '左下角', at: (w, h, bw, bh, c) => ({ x: clamp(c.right, 0, Math.max(0, w - bw)), y: clamp(h - c.bottom - bh, 0, Math.max(0, h - bh)) }) },
+        { label: '右下角', at: (w, h, bw, bh, c) => ({ x: clamp(w - c.right - bw, 0, Math.max(0, w - bw)), y: clamp(h - c.bottom - bh, 0, Math.max(0, h - bh)) }) },
+      ]
+
+      const goHome = () => goCorner('右下角')
+      /* 角落用法要计数，而 goCorner 是把人挪过去的唯一入口 —— 计数放在它里面最省事，
+         而且只有用户会触发它（初始位置是直接算坐标的，不走这里）。 */
+
+      const goCorner = (label) => {
+        const corner = CORNERS.find((c) => c.label === label) || CORNERS[CORNERS.length - 1]
+        const spot = corner.at(vw(), vh(), boxW(), boxH(), cfg)
+        coords.x = spot.x
+        coords.y = spot.y
         paint()
         rememberPosition()
         say(pick(LINES.home))
       }
+
+      /* 菜单分四段：动作 / 行为开关 / 位置 / 皮肤。后三段各有一个小标题。
+         行为开关原本在设置页里，但那页与菜单重叠过大被撤掉了 —— 这三个开关是面板
+         真正的净增量，放进菜单比再建一页便宜得多（复用现有的项结构、键盘支持与关闭逻辑）。 */
+      const TOGGLES = [
+        { key: 'wander', label: '自己溜达' },
+        { key: 'reactions', label: '跟随状态' },
+        { key: 'celebrate', label: '跑完撒花' },
+      ]
+
+      const menuItems = () => {
+        const items = [
+          { label: '说句话', run: () => { wake(true); say(pick(LINES.click)) } },
+          { label: '放大一点', run: () => applyConfig({ size: cfg.size + 0.5 }) },
+          { label: '缩小一点', run: () => applyConfig({ size: cfg.size - 0.5 }) },
+          /* 一个开关，不是一个单向动作：从迷你按钮右键打开菜单时，它必须能把她叫回来。 */
+          { label: hidden ? '回来吧' : '先躲起来', run: () => setHidden(!hidden) },
+          { label: '睡一会儿', run: () => setMood('sleep') },
+          { label: '版本与更新', run: () => showUpdate() },
+          { header: '行为' },
+        ]
+        for (const toggle of TOGGLES) {
+          const on = cfg[toggle.key] === true
+          items.push({
+            label: (on ? '✓ ' : '　') + toggle.label,
+            run: () => applyConfig({ [toggle.key]: !on }),
+          })
+        }
+        items.push({ header: '位置' })
+        for (const corner of CORNERS) {
+          items.push({ label: corner.label, run: () => goCorner(corner.label) })
+        }
+        items.push({ header: '皮肤' })
+        for (const id of SKIN_IDS) {
+          items.push({
+            label: (id === activeSkin ? '✓ ' : '　') + skinLabel(id),
+            skin: id,
+            run: () => {
+              if (id === activeSkin) return
+              applySkin(id)
+              say('换成' + skinLabel(id) + '了。')
+            },
+          })
+        }
+        return items
+      }
+
+      /* ---- 菜单的键盘驱动 ----
+         菜单已经声明了 role="menu"，没有键盘支持的话，对屏幕阅读器来说比不声明更糟 ——
+         它宣布了一个你无法操作的菜单。采用 roving tabindex：只有当前项 tabindex=0，
+         其余 -1，焦点本身用原生 .focus()。Enter/Space 不做显式处理 —— 焦点落在真正的
+         <button> 上，激活是浏览器原生行为，自己再拦一次会双重触发。 */
+      let menuButtons = []
+      let menuFocusAt = -1
+
+      const focusMenuItem = (at) => {
+        if (menuButtons.length === 0) return
+        const next = ((at % menuButtons.length) + menuButtons.length) % menuButtons.length
+        menuFocusAt = next
+        for (let i = 0; i < menuButtons.length; i++) {
+          const btn = menuButtons[i]
+          btn.tabIndex = i === next ? 0 : -1
+          btn.setAttribute('tabindex', i === next ? '0' : '-1')
+          btn.setAttribute('aria-selected', i === next ? 'true' : 'false')
+        }
+        const target = menuButtons[next]
+        if (target && typeof target.focus === 'function') {
+          try { target.focus() } catch (err) { /* 焦点不可用也不该让菜单崩掉 */ }
+        }
+      }
+
+      const focusHer = () => {
+        if (typeof bodyEl.focus === 'function') {
+          try { bodyEl.focus() } catch (err) { /* ignore */ }
+        }
+      }
+
+      const openMenu = (x, y) => {
+        closeMenu()
+        stopGlide()
+        const items = menuItems()
+        menuButtons = []
+        const menu = document.createElement('div')
+        menu.className = 'wisp-menu'
+        menu.setAttribute('role', 'menu')
+        menu.style.position = 'absolute'
+        for (let i = 0; i < items.length; i++) {
+          const spec = items[i]
+          if (spec.header !== undefined) {
+            // 小标题是分组标签，不是菜单项 —— 不能被聚焦，否则键盘用户会停在一个按不动的东西上
+            const head = document.createElement('div')
+            head.className = 'wisp-menu-head'
+            head.textContent = spec.header
+            menu.appendChild(head)
+            continue
+          }
+          const btn = document.createElement('button')
+          btn.className = 'wisp-menu-item'
+          btn.setAttribute('type', 'button')
+          btn.setAttribute('role', 'menuitem')
+          btn.setAttribute('tabindex', '-1')
+          btn.textContent = spec.label
+          // 菜单自己吞掉 pointerdown，否则会被下面那个"点外面就关"的监听判成外部点击
+          btn.addEventListener('pointerdown', (ev) => ev.stopPropagation())
+          btn.addEventListener('click', (ev) => {
+            ev.preventDefault(); ev.stopPropagation()
+            closeMenu()
+            try { spec.run() } catch (err) { /* 单个动作失败不该带塌整个菜单 */ }
+          })
+          menu.appendChild(btn)
+          menuButtons.push(btn)
+        }
+        // 先挂上去再定位：定位要用最终尺寸，而尺寸只有渲染后才知道
+        layer.appendChild(menu)
+        menuEl = menu
+        const w = MENU_W
+        // 高度只用于夹取落点，所以按条目类型估算即可（假 DOM 里没有布局可测）
+        let hs = MENU_PAD
+        for (const it of items) hs += it.header !== undefined ? 22 : MENU_ITEM_H
+        menu.style.left = Math.round(clamp(x, 8, Math.max(8, vw() - w - 8))) + 'px'
+        menu.style.top = Math.round(clamp(y, 8, Math.max(8, vh() - hs - 8))) + 'px'
+
+        const onOutside = () => closeMenu()
+        const onKey = (ev) => {
+          if (ev.key === 'Escape') {
+            closeMenu()
+            focusHer()          // 关掉之后焦点要回到她身上，不能掉进 <body>
+            return
+          }
+          if (menuButtons.length === 0) return
+          let at = menuFocusAt
+          if (ev.key === 'ArrowDown') at = at < 0 ? 0 : at + 1
+          else if (ev.key === 'ArrowUp') at = at < 0 ? menuButtons.length - 1 : at - 1
+          else if (ev.key === 'Home') at = 0
+          else if (ev.key === 'End') at = menuButtons.length - 1
+          else if (ev.key === 'Tab') { closeMenu(); return }   // Tab 离开 = 关掉，别把人困在菜单里
+          else return
+          if (typeof ev.preventDefault === 'function') ev.preventDefault()
+          focusMenuItem(at)
+        }
+        // 冒泡阶段（非捕获）：菜单项的 stopPropagation 才能拦住它
+        window.addEventListener('pointerdown', onOutside)
+        window.addEventListener('keydown', onKey, true)
+        window.addEventListener('resize', onOutside)
+        window.addEventListener('wheel', onOutside)
+        menuOff = () => {
+          window.removeEventListener('pointerdown', onOutside)
+          window.removeEventListener('keydown', onKey, true)
+          window.removeEventListener('resize', onOutside)
+          window.removeEventListener('wheel', onOutside)
+        }
+        // 打开即聚焦第一项：键盘用户不必先 Tab 进去
+        focusMenuItem(0)
+      }
+
+      const onContext = (e) => {
+        if (!hitsBody(e)) return
+        e.preventDefault(); e.stopPropagation()
+        openMenu(e.clientX, e.clientY)
+      }
       bodyEl.addEventListener('contextmenu', onContext)
 
       const onResize = () => {
@@ -975,21 +1882,65 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       window.addEventListener('resize', onResize)
 
       attach()
-      clock.after(800, () => say(pick(LINES.hello)))
+      /* 打招呼按时段取：凌晨三点和上午十点不该说同一句话。时段在**挂载时**取一次 ——
+         一个挂了一整天的页面不该在过零点后突然换口气，那反而像 bug。 */
+      const greetHour = hourNow()
+      const greetName = greetPoolName(greetHour)
+      clock.after(800, () => say(pick(greetPool(greetName))))
+
+      /* ---- 她更新了吗 --------------------------------------------------------
+         插件不能联网，所以"检查更新"它做不了。但**它知道自己现在是哪一版** —— 于是能做到
+         一件真事：上次见到的是旧版本，这次不是了，那就是更新过了，说一句。
+         第一次安装（没记录）不吭声：那时候她还没"更新"，只是刚来。 */
+      const seenVersion = readStored(SEEN_VERSION_KEY)
+      if (typeof seenVersion === 'string' && seenVersion !== VERSION) {
+        clock.after(1600, () => {
+          if (destroyed) return
+          flashHappy('我更新到 ' + VERSION + ' 了。')
+        })
+      }
+      writeStored(SEEN_VERSION_KEY, VERSION)
+      /* 记忆台词排在三件事之后：打招呼（0.8s）、首次右键提示（约 3.6s）。
+         曾经和提示撞在同一秒，结果两条互相盖掉 —— 挪到 7 秒，彼此都有位置。 */
+      if (cfg.reactions) {
+        clock.after(7000, () => {
+          if (destroyed) return
+          const remark = memoryRemark()
+          if (remark === null) return
+          if (remark.mood === 'proud') flashProud(remark.text)
+          else flashHappy(remark.text)
+        })
+      }
+      /* 第一次见面时提一句右键 —— 菜单是主要入口，但从外观上完全看不出来。
+         只提一次：第二次见面还念叨就成了骚扰。 */
+      if (cfg.persist && readStored(HINT_KEY) === null) {
+        clock.after(3600, () => {
+          if (destroyed) return
+          say(pick(LINES.hint))
+          writeStored(HINT_KEY, { told: true })
+        })
+      }
       wake(true)
+      if (hidden) showTab()
 
       /* warm the other sprites after the first frame so mood changes never blink */
       clock.after(1500, () => {
         if (destroyed) return
-        for (const key in SPRITES) {
+        for (const key in SPRITES[activeSkin]) {
           if (key === currentSprite) continue
           const pre = new Image()
-          pre.src = resolveSprite(SPRITES[key])
+          pre.src = resolveSprite(spriteOf(key))
         }
       })
 
       const applyConfig = (partial) => {
         mergeConfig(cfg, partial)
+        // configure({skin: '…'}) 也要能换皮肤，否则配置与菜单两条路会不一致
+        if (partial && typeof partial.skin === 'string' && partial.skin !== '') applySkin(partial.skin)
+        // 尺寸也要活过刷新：位置/皮肤/隐藏都记了，只有尺寸不记会显得前后不一致
+        if (cfg.persist && partial && typeof partial === 'object' && partial.size !== undefined) {
+          writeStored(PREFS_KEY, { size: cfg.size })
+        }
         // A bigger companion occupies a bigger box, so the stored position has
         // to be re-clamped or she would grow off the edge.
         root.style.width = Math.round(boxW()) + 'px'
@@ -1002,9 +1953,116 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         syncPoll()
         syncChatter()
         syncWander()
+        // 开关 backdrop 之后要立刻生效，不用刷新页面
+        if (partial && typeof partial === 'object' && partial.backdrop !== undefined) {
+          backdropReport = applyBackdrop()
+        }
         return api
       }
 
+      /* ---- 检查更新 -----------------------------------------------------------
+         浏览器半包的 fetch 是教学陷阱，宿主半包又在 vm 沙箱里没有 Node API ——
+         所以这条必须走**平台给的服务**：宿主半包 inject 'web'，用 ctx.web.fetch 抓
+         远端 package.json，再用 harness.handle 注册成 checkUpdate，这边用 host.call 调。
+
+         host 是 shell 注入的名字，不是全局：拿不到就如实说"查不了"，不许抛。 */
+      let updateCheck = { state: 'idle', at: 0 }
+
+      const compareVersions = (a, b) => {
+        const parse = (v) => String(v).split('-')[0].split('.').map((n) => {
+          const x = Number.parseInt(n, 10)
+          return Number.isFinite(x) ? x : 0
+        })
+        const left = parse(a)
+        const right = parse(b)
+        for (let i = 0; i < Math.max(left.length, right.length); i++) {
+          const l = left[i] ?? 0
+          const r = right[i] ?? 0
+          if (l !== r) return l < r ? -1 : 1
+        }
+        return 0
+      }
+
+      /* shell 把 host 作为闭包符号给它；typeof 对未声明名字是安全的，
+         但如果 shell 根本没提供，这里只会得到 undefined，不会炸。 */
+      const hostSeat = () => {
+        try {
+          if (typeof host !== 'undefined' && host && typeof host.call === 'function') return host
+        } catch (e) { /* 没这个座位 */ }
+        return null
+      }
+
+      const checkForUpdate = () => {
+        const seat = hostSeat()
+        if (seat === null) {
+          updateCheck = { state: 'unsupported', at: nowMs() }
+          return Promise.resolve(updateCheck)
+        }
+        updateCheck = { state: 'checking', at: nowMs() }
+        return Promise.resolve()
+          .then(() => seat.call('checkUpdate', { current: VERSION }))
+          .then((res) => {
+            if (!res || res.ok !== true || typeof res.latest !== 'string') {
+              updateCheck = { state: 'failed', reason: (res && res.reason) || 'no-result', at: nowMs() }
+            } else if (compareVersions(VERSION, res.latest) < 0) {
+              updateCheck = { state: 'available', latest: res.latest, at: nowMs() }
+            } else {
+              updateCheck = { state: 'current', latest: res.latest, at: nowMs() }
+            }
+            return updateCheck
+          })
+          .catch((err) => {
+            updateCheck = {
+              state: 'failed',
+              reason: 'call-failed',
+              detail: String(err && err.message ? err.message : err),
+              at: nowMs(),
+            }
+            return updateCheck
+          })
+      }
+
+      const updateLine = (res) => {
+        if (res.state === 'available') return pick(LINES.updateAvailable) + res.latest
+        if (res.state === 'current') return pick(LINES.updateCurrent)
+        return pick(LINES.updateFailed)
+      }
+
+      /* 把包名复制到剪贴板，便于在 DSH 的「按插件包名安装」里粘贴。
+         没有剪贴板权限（或不是安全上下文）时**静默降级**成只说话 —— 不该因此报错。 */
+      const copyText = (text) => {
+        try {
+          const nav = window.navigator
+          const cb = nav && nav.clipboard
+          if (cb && typeof cb.writeText === 'function') {
+            const p = cb.writeText(text)
+            if (p && typeof p.catch === 'function') p.catch(() => {})
+            return true
+          }
+        } catch (e) { /* 降级 */ }
+        return false
+      }
+
+      /* 「版本与更新」：说出当前版本与这一版的要点，并把包名复制好。
+         用户点这一项想知道的就是这两件事。 */
+      const showUpdate = () => {
+        const note = WHATS_NEW[VERSION]
+        const copied = copyText('dsh-wisp')
+        /* 一步到位：先把"我是谁、这一版做了什么"说出来，同时去查有没有新版；
+           查回来再用一句话覆盖掉 —— 一次只冒一个气泡，所以是"说完结果就结束"。 */
+        const base = '我是 ' + VERSION + '。'
+        flashHappy(note ? base + note : base)
+        const started = checkForUpdate()
+        if (started && typeof started.then === 'function') {
+          started.then((res) => {
+            if (destroyed) return
+            if (res.state === 'checking') return
+            flashHappy(base + updateLine(res))
+          })
+        }
+        return { version: VERSION, note: note || null, copied, checking: true }
+      }
+
       const api = {
         version: VERSION,
         clock: clock.mode,
@@ -1019,7 +2077,155 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           paint()
         },
         get element() { return root },
-        get sprites() { return Object.keys(SPRITES) },
+        get sprites() { return Object.keys(SPRITES[activeSkin]) },
+        get skins() { return SKIN_IDS.slice() },
+        /* 读用 skin、写用 setSkin。同一个对象字面量里 get skin() 与 skin: fn
+           不能共存 —— 后者会静默覆盖前者，读出来就成了函数。 */
+        get skin() { return activeSkin },
+        setSkin: applySkin,
+        showUpdate,
+        checkForUpdate,
+        get updateCheck() { return { ...updateCheck } },
+        get hidden() { return hidden },
+        hide: () => setHidden(true),
+        show: () => setHidden(false),
+        /* 读实时配置（Console 里 `__wisp.config` 是唯一能看到生效值的地方）。给的是副本。 */
+        get config() { return Object.assign({}, cfg) },
+        goCorner,
+
+        /* -----------------------------------------------------------------
+           doctor() —— 自检：这个页面里，插件依赖的每个钩子到底能不能解析。
+
+           存在的理由：这些选择器是我读 DSH 源码推出来的，而**它们错了不会有任何报错** ——
+           对应的功能只是永远不触发，看起来像"她今天没反应"。而插件跑在带鉴权的页面里，
+           外部脚本（包括我这边的浏览器）连不上，所以自检必须由插件自己在页面里提供。
+
+           只读，无副作用。Console 里敲 `__wisp.doctor()` 即可。
+           ----------------------------------------------------------------- */
+        doctor() {
+          const probe = (selector) => {
+            try { return document.querySelectorAll(selector).length } catch (e) { return -1 }
+          }
+          const composer = COMPOSER_HOOKS.map((selector) => ({ selector, matches: probe(selector) }))
+          const pending = PENDING_ATTRS.map((attr) => ({
+            selector: '[' + attr + ']',
+            matches: probe('[' + attr + ']'),
+          }))
+          const body = document.body
+          /* 走 window. 而不是裸全局：客户端半包可能运行在"被提供的 window ≠ 环境全局"之下，
+             裸 getComputedStyle 会解析到别处（或不存在）。nowMs 当初就是这么坏掉的。 */
+          const style = body && window && typeof window.getComputedStyle === 'function'
+            ? window.getComputedStyle(body)
+            : null
+          const tokens = THEME_TOKENS.map((token) => ({
+            token,
+            value: style ? style.getPropertyValue(token).trim() : '',
+          }))
+
+          /* 把"数字"翻译成"哪个功能会失效"，否则这份报告没人看得懂。
+             只列**真的意味着失效**的条件：待处理面板与出错行缺席是正常状态，
+             把它们算进 problems 只会训练人忽略这份清单。 */
+          const problems = []
+          if (!composer.some((h) => h.matches > 0)) {
+            problems.push('输入框钩子一个都没匹配到 —— 若你此刻正开着会话（能看到输入框），'
+              + '就是钩子失效了：「你在打字时她进入待命」不会触发')
+          }
+          if (tokens.every((t) => t.value === '')) {
+            problems.push('主题令牌全为空 → 亮暗跟随退化成默认色')
+          }
+          if (!body) problems.push('document.body 不存在')
+
+          const busyMatches = probe(STOP_SELECTOR)
+          /* 忙碌钩子是唯一无法静态确认的：它的 aria-label 来自语言表，而不是源码里的字面量
+             （其余 data-* 钩子我已在已发布的 app.asar 里逐个确认存在）。所以找不到时，把页面上
+             实际存在的按钮 aria-label 一起报出来 —— 一次 doctor() 就能看出真正的标签是什么。 */
+          const sampleAriaLabels = () => {
+            try {
+              const all = document.querySelectorAll('button[aria-label]')
+              const out = []
+              for (let i = 0; i < all.length && out.length < 12; i++) {
+                const label = all[i].getAttribute('aria-label')
+                if (label && out.indexOf(label) < 0) out.push(label)
+              }
+              return out
+            } catch (e) {
+              return []
+            }
+          }
+
+          return {
+            version: VERSION,
+            clock: clock.mode,
+            mood,
+            skin: activeSkin,
+            hidden,
+            position: { x: Math.round(coords.x), y: Math.round(coords.y) },
+            config: Object.assign({}, cfg),
+            hooks: {
+              composer,
+              busy: busyMatches === 0
+                ? { selector: STOP_SELECTOR, matches: 0, ariaLabelsOnPage: sampleAriaLabels() }
+                : { selector: STOP_SELECTOR, matches: busyMatches },
+              pending,
+              error: { selector: ERROR_SELECTOR, matches: probe(ERROR_SELECTOR) },
+            },
+            dark: !!(body && body.hasAttribute('data-ds-dark-theme')),
+            tokens,
+            /* 窗口背景：Mica 能不能露出来，取决于页面有没有在背景处画不透明像素。
+               blockers 是"每个采样点上最上面那个铺满视口的画底色的元素"，
+               cleared 是已经被清掉的那些 —— 一眼就能看出有没有找对。 */
+            backdrop: {
+              enabled: !!cfg.backdrop,
+              blockers: backdropReport.blockers,
+              cleared: backdropReport.cleared,
+              skipped: backdropReport.skipped,
+              errors: backdropReport.errors,
+            },
+            /* 页面上到底有几个她。只要不是 1 就是 bug，而这件事必须能被一眼看见 ——
+               "出现了两个她"最早是从用户嘴里知道的，不该是这样。 */
+            /* 更新相关的实情：当前版本、这一版做了什么、以及更新该走哪条路。
+               注意：插件自己**没有**联网能力，这里给的是"怎么做"，不是"帮你做"。 */
+            update: {
+              version: VERSION,
+              whatsNew: WHATS_NEW[VERSION] ?? null,
+              seenBefore: readStored(SEEN_VERSION_KEY),
+              hint: UPDATE_HINT,
+              canSelfUpdate: false,
+              /* 上一次检查的结果（idle / checking / current / available / failed / unsupported） */
+              lastCheck: { ...updateCheck },
+              why: '宿主半包在 vm 沙箱里，harness 只有 defineTool/registerTool/handle，Node API 被 nodeApiTraps 挡住',
+            },
+            /* 今日轮次：不用猜"她为什么突然得意"，数字就在这里 */
+            runsToday: { day: runsToday.day, count: runsToday.count, said: runsToday.said.slice() },
+            /* 她记着你：一起多少天、习惯放在哪、常穿哪套、已经说过哪些 */
+            memory: {
+              days: memory.days.length,
+              topCorner: topOf(memory.corners),
+              topSkin: topOf(memory.skins),
+              said: memory.said.slice(),
+              remarkDay: memory.remarkDay,
+            },
+            instances: (() => {
+              try {
+                return { layers: document.querySelectorAll('.wisp-layer').length, roots: document.querySelectorAll('.wisp-root').length }
+              } catch (e) { return { layers: -1, roots: -1 } }
+            })(),
+            /* 时段招呼：报告当前用的是哪一套、几分钟前算的。她在凌晨和上午的口气不同，
+               而这些文案是按小时选的 —— 报告出来，就不用靠猜"她现在为什么这么说"。 */
+            greeting: {
+              pool: greetName,
+              hour: greetHour,
+              poolSize: greetPool(greetName).length,
+              pools: { morning: LINES.morning.length, afternoon: LINES.afternoon.length, evening: LINES.evening.length, night: LINES.night.length },
+            },
+            problems,
+            /* 已知的下一步：SessionSnapshot 里有权威的 `running` 与 `lastAgentError`
+               （经 sessions.binding(id).session）。它比 busy/error 两个 DOM 选择器可靠得多，
+               但需要先拿到当前会话 id，而且我无法在带鉴权的页面外验证 —— 所以先记在这里。 */
+            sessionsService: !!(ctx && typeof ctx.get === 'function' && ctx.get('sessions')),
+          }
+        },
+        get skinLabels() { return SKIN_IDS.map((id) => ({ id, label: skinLabel(id) })) },
         get position() { return { x: Math.round(coords.x), y: Math.round(coords.y) } },
         get currentMood() { return mood },
         destroy() {
@@ -1032,13 +2238,18 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           window.removeEventListener('pointermove', onMove)
           window.removeEventListener('pointerup', onUp)
           bodyEl.removeEventListener('pointerdown', onDown)
+          bodyEl.removeEventListener('keydown', onBodyKey)
           bodyEl.removeEventListener('contextmenu', onContext)
+          closeMenu()
+          hideTab()
           if (typeof offTheme === 'function') {
             try { offTheme() } catch (e) { /* ignore */ }
             offTheme = null
           }
           if (typeof styleDispose === 'function') {
             try { styleDispose() } catch (e) { /* ignore */ }
+        /* 背景规则也要收掉：她自己的东西必须自己清干净，不能留在页面上 */
+        removeBackdropStyle()
           }
           if (layer.parentNode) layer.remove()
           revokeSprites()