dsh-wisp 1.28.0 → 1.30.0

package/README.md

@@ -448,6 +448,71 @@ node tools/audit-log.mjs --confirm <manifest>     # 生成后：并入代理登
 
 ## 变更
 
+### 1.30.0
+
+这一版是**功能**，不是台词。
+
+- **专注计时器。** 桌面陪伴插件最该有的实用功能：替你画出一段时间的边界。
+
+  - 菜单「行为」组里「**专注 25 分钟**」/「**专注 45 分钟**」（默认时长 `focusMinutes`），
+    专注中多一条「**结束专注**」（平时不出现 —— 菜单里不该有按不动的条目）；
+  - 专注期间**她保持"干活中"的姿势**：稳态轮询不许把她挪走 ✓。这条 hold 放在久坐 / 干饭 /
+    劝睡**之后** —— 那三件事该响还得响，只是姿势归专注管；
+  - **戳她一下 = 问还剩多久**（*"还有 23 分钟呢，盯着屏幕。"*），而且不计入"连戳"，
+    不会升级成抗议；
+  - 到点她换 `proud` 说收工（*"这一轮 25 分钟，结束了。"*），`doctor().focus.done` 累计完成次数；
+  - 她**不碰应用**：不改输入框、不发消息、不点任何按钮 —— 只陪着 + 计时。
+
+- **页面藏起来就安静。** 挂 `visibilitychange`：藏起来时停掉**轮询 / 絮叨 / 踱步**三个定时器，
+  回来再按配置重新挂上。没人在看的时候不该空转 CPU（顺带省电）。
+
+  - 这不是"少做点事"而是"诚实"：藏起来期间 DOM 再吵她也不该有反应 —— 测试就是这么断言的
+    （藏起来时来三个报错她一声不吭；回来之后同一批报错立刻被看见）；
+  - 恢复**先于**问候：先保证活着，再谈礼貌；
+  - `doctor().timers` 报告 `{ poll, chatter, wander, paused }`。
+
+- 预检 451 → **473 项**。
+
+- 记一个测试教训：戳她要用**既有的那套姿势**（`pointerdown` 落在 `.wisp-body`、
+  `pointerup` 落在 `window`、坐标要在她身上）—— 我第一版两个事件都发到 `root` 上，
+  她当然没反应，白查了一轮。
+
+### 1.29.0
+
+### 1.29.0
+
+三件和"她真的陪着你"有关的事。都不需要新素材，全是行为 + 台词。
+
+- **夜深了她会劝你去睡。** 过了 `bedtimeHour`（默认 **23**）她换一种口气，过了入睡**两小时**
+  换成"嘴硬心软"那一档 —— 后者是社区设定里她的底色（*"我不管你，但……真的该睡了。"*、
+  *"才不是担心你，只是我不想半夜还看着屏幕。"*、*"你要是倒下，我可没有备份。"*）。
+
+  - **作息是可配的**（`bedtimeHour` / `wakeHour`，默认 23 → 5，跨零点）——
+    这既是真功能（各人作息不同），也让测试**不必伪造时钟**：把窗口套在当前那个小时上，
+    该响就得响，套偏一小时就该安静；
+  - 深度档按**入睡后经过的小时数**算，不是按"小时落在某个绕圈区间里"——
+    后者在窄窗口下会把窗外一大段时间也算成深夜（写测试时当场撞上：13 点睡、14 点起，
+    结果 13 点自己被判成"深度深夜"）；
+  - 菜单「行为」组里多了「**深夜劝睡**」开关，另有 `nightMs`（默认 30 分钟一次；0 = 关）。
+
+- **你离开又回来，她记得。** 挂 `visibilitychange` 记住离开的时刻，回来按时长分两档：
+  短走一句（*"回来了。"*、*"位置我没动。"*）、长走（15 分钟以上）另一句
+  （*"你走了好久。"*、*"我还以为你把我关了。"*）。阈值 `backAfterMs`，默认 2 分钟，0 = 关。
+
+- **连续天数。** 从今天往回数，记忆里一天不落有多长 —— 第 2 天起她会提
+  （*"我们已经连着见了 4 天。"*），到 **7 / 30 / 100 / 365** 天换一句里程碑。
+  断了就回到 1，而且**一句都不说**（"连续第 1 天"很怪）。`doctor().streak` 可查。
+
+- `doctor()` 新增 `night`（窗口 / 深度档起点 / 当前小时 / 上次提醒时间）、`streak`、`awaySince`
+  —— 不用猜"她为什么突然劝我睡觉"。
+
+- 预检 435 → **451 项**。
+
+- 顺手记一个测试教训：气泡只活几秒，**"推进完再看"必然看不到** ——
+  久坐提醒那节早就踩过，这次又踩了一遍。现在统一用 `watch(h, ms)` 边推进边收集。
+
+### 1.28.0
+
 ### 1.28.0
 
 - **菜单不再是 19 个同级条目。** 原来 6 个动作 + 4 个开关 + 4 个角落 + 5 套皮肤全平铺，

package/lib/client.js

@@ -51,7 +51,7 @@ window.__ModuleLoader__.load({
     var exports = module.exports
     Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 
-    const VERSION = '1.28.0'
+    const VERSION = '1.30.0'
 
 /* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
    忘了更新就会红，不会静默过期。 */
@@ -69,6 +69,8 @@ const WHATS_NEW = {
   '1.26.0': '检查更新同时读 npm 和 GitHub，取更高的那个版本。',
   '1.27.0': '她饿了会捧出一碗白米饭，还有第八个表情。',
   '1.28.0': '菜单分成折叠分组，另外多了「关于她」和「动作一览」两个弹窗。',
+  '1.29.0': '夜深了她会劝你去睡；你走开再回来她记得；连续来了几天她也记着。',
+  '1.30.0': '会陪你专注计时了；页面藏起来时她会安静下来，不再空转。',
 }
 
 /* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
@@ -215,6 +217,12 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       careAfterMs: 5400000,     // 连续活动这么久之后提醒你起来动动（90 分钟；0 = 关）
       hungry: true,             // 干饭：她饿了会说
       hungerMs: 2700000,        // 连续活动这么久就该吃一碗了（45 分钟；0 = 关）
+      focusMinutes: 25,         // 菜单里「专注 N 分钟」用的默认时长
+      night: true,              // 深夜劝睡
+      bedtimeHour: 23,          // 几点算深夜（0-23）
+      wakeHour: 5,              // 几点算天亮（0-23）；bedtime > wake 时窗口跨零点
+      nightMs: 1800000,         // 深夜每隔这么久说一句（30 分钟；0 = 关）
+      backAfterMs: 120000,      // 离开超过这么久，回来时她会说一句（2 分钟；0 = 关）
       milestones: true,         // 今日轮次到达里程碑时得意一下
       memory: true,             // 她记着你：一起多少天 / 常放哪个角 / 常穿哪套
       happyMs: 1100,
@@ -318,6 +326,44 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
         '算力不够了，得补点碳水。', '电量告急，切待机。', '你要不要也来一口？',
         '这碗不算加餐，算基础设施。', '吃饱了才有力气摸鱼。', '饭碗见底了，该续命了。', '我数着米粒呢。',
       ],
+      /* 专注计时器。她是陪着你干活的，所以"替你画出一段时间的边界"比再多说几句更实在。 */
+      focusStart: [
+        '{n} 分钟。开始吧。', '好，{n} 分钟，我盯着你。', '计时开始，{n} 分钟。', '{n} 分钟不看别的。',
+        '这段时间归你了。{n} 分钟。',
+      ],
+      focusDone: [
+        '{n} 分钟到了。收工。', '{n} 分钟，干完了？', '时间到。{n} 分钟，去喝口水。', '{n} 分钟到了 —— 站起来伸个懒腰。',
+        '这一轮 {n} 分钟，结束了。',
+      ],
+      focusStop: ['行，那就先到这儿。', '不专注了？那我歇着。', '计时取消了。', '好吧，下次再说。'],
+      focusLeft: [
+        '还有 {n} 分钟。', '{n} 分钟，快了。', '还剩 {n} 分钟，别分心。', '还有 {n} 分钟呢，盯着屏幕。',
+      ],
+      /* 深夜劝睡：23 点后一种语气，凌晨 1 点后另一种 —— 后者是社区设定里"嘴硬心软"那一档。
+         分档按 bedtimeHour + 2 推导，所以改了作息这套分档也跟着走。 */
+      nightLate: [
+        '十一点了。', '该收的东西收一收吧。', '我不催你，时钟在催。', '这个点还在跑，明天会还债的。',
+        '夜里的屏幕最亮，眼睛最累。', '再干一会儿就收工？', '白天的你会感谢现在的你。', '我给你留着灯。',
+        '要不要把剩下的留到明天？', '深夜的算力也是算力，但人也得睡。', '我先打个盹，你随意。', '这时候的安静挺值钱的。',
+      ],
+      nightDeep: [
+        '一点了。', '我不管你，但……真的该睡了。', '明天再跑也一样，代码不会跑。', '再撑下去，明天会很难受。',
+        '才不是担心你，只是我不想半夜还看着屏幕。', '你要是倒下，我可没有备份。', '这个点做的决定，白天多半会后悔。',
+        '我数到十你就去睡。……一。', '熬夜是拿明天的算力换今晚的。', '天快亮了，你还在这儿。',
+        '我要是能关灯就好了。', '睡吧。我留在这儿。',
+      ],
+      /* 离开又回来：按走了多久分两档（阈值见 backAfterMs / BACK_LONG_MS）。 */
+      backSoon: [
+        '回来了。', '刚才去哪了。', '我在这儿等着呢。', '一眼没看见你。', '这么快就回来，水都没喝吧。', '位置我没动。',
+      ],
+      backLong: [
+        '你走了好久。', '差点以为今天见不到了。', '回来了就好。', '我一直在这儿。', '这么久，是去吃饭了吗？',
+        '屏幕都凉了。', '我还以为你把我关了。', '下次说一声，我就不数时间了。',
+      ],
+      /* 连续天数（{n} 是天数） */
+      streak: [
+        '连续第 {n} 天了。', '第 {n} 天了，你还在。', '我们已经连着见了 {n} 天。', '第 {n} 天。我记着呢。', '{n} 天没断，挺厉害的。',
+      ],
       updateCurrent: ['已经是最新的了。', '我就是最新的。', '没有更新的。'],
       updateAvailable: ['有新版本了：', '有新版：', '更新来了：'],
       updateFailed: ['更新没查成。', '这次没查到更新。', '更新检查没成功。'],
@@ -334,6 +380,37 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       hint: ['右键我一下试试。', '右键我有菜单。', '拖我，或者右键我。'],
     }
 
+    /* 深夜窗口。bedtime > wake 时它跨零点（默认 23→5）；不跨也能用（比如 1→5）。 */
+    const isNightHour = (hour, from, to) => {
+      if (from === to) return false
+      return from > to ? (hour >= from || hour < to) : (hour >= from && hour < to)
+    }
+    /* "深度深夜"= 已经过了入睡时间两小时以上。按**经过的小时数**算，而不是按绕圈区间：
+       后者在窄窗口（比如 13 点睡、14 点起）会把窗外的一大段时间也算进来。 */
+    const DEEP_AFTER_HOURS = 2
+    const hoursSince = (hour, from) => (((hour - from) % 24) + 24) % 24
+    const deepHourOf = (bedtime) => (Math.round(bedtime) + DEEP_AFTER_HOURS) % 24
+
+    /* 连续天数：从今天往回数，memory.days 里一天不落有多长。
+       用毫秒回推而不是解析日期字符串 —— dayKey() 产出的 2026-9-30 不是 ISO 形式，
+       各引擎对它的解析并不一致。 */
+    const dayKeyOf = (ms) => {
+      try {
+        const d = new Date(ms)
+        return d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate()
+      } catch (e) { return 'unknown' }
+    }
+    const streakOf = (days) => {
+      if (!Array.isArray(days) || days.length === 0) return 0
+      const set = new Set(days)
+      let n = 0
+      let t = Date.now()
+      while (n < 400 && set.has(dayKeyOf(t))) { n++; t -= 86400000 }
+      return n
+    }
+    /* 连续天数的里程碑；到了才说一次。 */
+    const STREAK_MILESTONES = [7, 30, 100, 365]
+
     /* 时段划分：凌晨与白天说话的口气不一样。深夜跨了两天，所以按"< 5 点"算夜里。 */
     const greetPoolName = (hour) => {
       if (hour < 5 || hour >= 22) return 'night'
@@ -388,6 +465,12 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       careAfterMs: { kind: 'num', lo: 0, hi: 86400000 },
       hungry: { kind: 'bool' },
       hungerMs: { kind: 'num', lo: 0, hi: 86400000 },
+      focusMinutes: { kind: 'num', lo: 1, hi: 600 },
+      night: { kind: 'bool' },
+      bedtimeHour: { kind: 'num', lo: 0, hi: 23 },
+      wakeHour: { kind: 'num', lo: 0, hi: 23 },
+      nightMs: { kind: 'num', lo: 0, hi: 86400000 },
+      backAfterMs: { kind: 'num', lo: 0, hi: 86400000 },
       milestones: { kind: 'bool' },
       memory: { kind: 'bool' },
       happyMs: { kind: 'num', lo: 200, hi: 10000 },
@@ -1391,6 +1474,9 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       let lastCareAt = 0
       /* 上一顿饭的时间。起手是 0，所以计时以 activeSince 为准 —— 见下面 mealBase。 */
       let lastMealAt = 0
+      /* 上一次深夜劝睡；离开又回来的时间点。 */
+      let lastNightAt = 0
+      let awayAt = 0
       let happyHandle = null
       let lastErrorCount = 0
 
@@ -1430,6 +1516,18 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         pokedHandle = clock.after(POKED_MS, () => { if (mood === 'poked') setMood('idle') })
       }
 
+      /* 打盹：深夜劝睡用它（一个哈欠比一条通知更像她）。睡着是瞬时状态，
+         自己到期就回稳态。 */
+      const NAP_MS = 5200
+      let napHandle = null
+      const flashSleepy = (text) => {
+        if (mood === 'sleep') wake(true)
+        setMood('sleep')
+        say(text)
+        if (napHandle) clock.cancel(napHandle)
+        napHandle = clock.after(NAP_MS, () => { if (mood === 'sleep') setMood('idle') })
+      }
+
       /* 干饭用的也是瞬时状态（借 eat 的姿态）。比"提醒你活动"长一点 ——
          吃饭本来就慢。 */
       const EAT_MS = 5200
@@ -1531,6 +1629,21 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           flashEat(pick(LINES.eat))
         }
 
+        /* ---- 深夜劝睡 ---------------------------------------------------------
+           作息**是可配的**（bedtimeHour / wakeHour），所以它既是一项真功能，
+           也让测试不必伪造时钟 —— 把窗口套在当前那个小时上就能测。
+           深度深夜从 bedtime + 2 起算，语气换一档：从"该收了"变成"嘴硬心软"。 */
+        if (cfg.night && cfg.nightMs > 0) {
+          const hour = hourNow()
+          const nightBase = Math.max(lastNightAt, activeSince)
+          if (isNightHour(hour, cfg.bedtimeHour, cfg.wakeHour)
+            && nowTick - nightBase >= cfg.nightMs) {
+            lastNightAt = nowTick
+            const deep = hoursSince(hour, cfg.bedtimeHour) >= DEEP_AFTER_HOURS
+            flashSleepy(pick(deep ? LINES.nightDeep : LINES.nightLate))
+          }
+        }
+
         // 有东西在等她处理时，优先级高于一切：这是唯一"你不理它就卡住"的状态。
         const pending = cfg.reactions ? readPending() : null
         if (pending === null) {
@@ -1545,6 +1658,13 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           return
         }
 
+        /* 专注期间不让稳态把她从"干活中"挪走 —— 她在盯着你，这是这个功能的全部意义。
+           位置在这里而不是函数开头：久坐、干饭、劝睡该响还得响。 */
+        if (focusUntil > 0) {
+          if (mood !== 'alert') setMood('alert')
+          return
+        }
+
         // 临时状态（happy / worried）在自己的计时器到期前不能被稳态赋值覆盖 ——
         // 否则刚摆出的表情在同一个 poll 周期里就被 setMood('idle') 抹掉了。
         if (mood === 'sleep' || mood === 'happy' || mood === 'poked' || mood === 'proud' || mood === 'care'
@@ -1554,10 +1674,62 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         setMood((busy || typing) ? 'alert' : 'idle')
       }
 
+      /* ---- 专注计时器 ---------------------------------------------------------
+         桌面陪伴插件最该有的实用功能：替你画出一段时间的边界。
+         专注期间她保持"干活中"的姿势（poll 里给她一个 hold —— 否则稳态会把她挪走），
+         到点收工庆祝；戳她一下就是问"还剩多久"。
+         她**不碰应用**：不改输入框、不发消息，只是陪着 + 计时。 */
+      let focusUntil = 0
+      let focusHandle = null
+      let focusMinutes = 0
+      let focusDone = 0
+
+      const focusLeftMs = () => Math.max(0, focusUntil - nowMs())
+      const focusState = () => (focusUntil > 0
+        ? { active: true, minutes: focusMinutes, leftMs: Math.round(focusLeftMs()), leftMin: Math.max(1, Math.ceil(focusLeftMs() / 60000)), done: focusDone }
+        : { active: false, minutes: 0, leftMs: 0, leftMin: 0, done: focusDone })
+
+      const stopFocus = (silent) => {
+        if (focusUntil === 0 && focusHandle === null) return false
+        focusUntil = 0
+        focusMinutes = 0
+        if (focusHandle) { clock.cancel(focusHandle); focusHandle = null }
+        if (silent !== true) {
+          wake(true)
+          flashHappy(pick(LINES.focusStop))
+        }
+        return true
+      }
+
+      const finishFocus = () => {
+        const minutes = focusMinutes
+        focusUntil = 0
+        focusHandle = null
+        focusMinutes = 0
+        focusDone++
+        wake(true)
+        flashProud(pick(LINES.focusDone).split('{n}').join(String(minutes)))
+      }
+
+      const startFocus = (minutes) => {
+        const mins = clamp(Math.round(Number(minutes) || cfg.focusMinutes), 1, 600)
+        stopFocus(true)
+        focusMinutes = mins
+        focusUntil = nowMs() + mins * 60000
+        wake(true)
+        say(pick(LINES.focusStart).split('{n}').join(String(mins)))
+        focusHandle = clock.after(mins * 60000, () => { if (focusUntil > 0) finishFocus() })
+        return focusState()
+      }
+
+      /* 没人在看的时候别空转：页面藏起来就停掉轮询、絮叨、踱步三个定时器。
+         它们本来就是"给看得见的人看的"，停下来是纯赚（CPU 与电量）。 */
+      let paused = false
+
       let chatterHandle = null
       const syncChatter = () => {
         if (chatterHandle) { clock.cancel(chatterHandle); chatterHandle = null }
-        if (cfg.chatterMs <= 0) return
+        if (cfg.chatterMs <= 0 || paused) return
         chatterHandle = clock.every(cfg.chatterMs, () => {
           if (destroyed || mood !== 'idle') return
           if (agentIsBusy()) return
@@ -1568,7 +1740,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       let pollHandle = null
       const syncPoll = () => {
         if (pollHandle) { clock.cancel(pollHandle); pollHandle = null }
-        if (cfg.reactions) pollHandle = clock.every(POLL_MS, poll)
+        if (cfg.reactions && !paused) pollHandle = clock.every(POLL_MS, poll)
       }
       syncPoll()
       syncChatter()
@@ -1595,7 +1767,7 @@ 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 }
-        if (!cfg.wander || cfg.wanderRange <= 0) return
+        if (!cfg.wander || cfg.wanderRange <= 0 || paused) return
         wanderHandle = clock.every(cfg.wanderMs, () => {
           if (destroyed || hidden || mood !== 'idle' || start !== null) return
           if (agentIsBusy()) return
@@ -1725,6 +1897,12 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (now - pokeWindowStart > POKE_WINDOW_MS) { pokeWindowStart = now; pokeStreak = 0 }
         pokeStreak++
         wake(true)
+        /* 专注中戳她是在问进度，不算戳着玩（也就不会升级成"抗议"）。 */
+        if (focusUntil > 0) {
+          const left = Math.max(1, Math.ceil(focusLeftMs() / 60000))
+          say(pick(LINES.focusLeft).split('{n}').join(String(left)))
+          return
+        }
         if (pokeStreak >= POKE_ANNOYED_AT) {
           pokeStreak = 0
           flashPoked(pick(LINES.poked))
@@ -1849,6 +2027,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         { key: 'reactions', label: '跟随状态' },
         { key: 'celebrate', label: '跑完撒花' },
         { key: 'hungry', label: '饿了会说话' },
+        { key: 'night', label: '深夜劝睡' },
       ]
 
       /* ---- 弹窗 ----------------------------------------------------------------
@@ -2000,6 +2179,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           para('DeepSeek娘 —— DSH 界面上的浮动桌宠。她会跟着你的状态换表情：你打字她在忙，你闲着她在晃，你跑完一轮她替你高兴。'),
           para('她的样子照社区规范来：深蓝色渐变长直发、头顶一个大圆环呆毛、两片鲸鳍耳、女仆装。'),
           para('白米饭是算力的硬通货 —— 所以她每隔一阵会捧碗出来补点碳水。'),
+          para('她还能陪你专注计时：菜单里开一段 25 或 45 分钟，期间她保持"干活中"，戳她一下是问还剩多久，到点她替你收工。'),
           para('这一版：' + (note || VERSION)),
           para('形象与设定参考社区项目 Neko3000/deepseek-whalechan（设定文档 CC BY-NC-SA 4.0，原作者 B站 ZipZipPipe、上善无形）。'),
           dialogFoot('非官方同人作品，与 DeepSeek 官方无关', 'v' + VERSION),
@@ -2031,6 +2211,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           children: [
             { label: '说句话', run: () => { wake(true); say(pick(LINES.click)) } },
             { label: '睡一会儿', run: () => setMood('sleep') },
+            { label: '专注 ' + cfg.focusMinutes + ' 分钟', run: () => startFocus(cfg.focusMinutes) },
+            { label: '专注 45 分钟', run: () => startFocus(45) },
+            /* 只有专注中才出现"结束专注" —— 平时的菜单不该多一个按不动的条目 */
+            ...(focusUntil > 0 ? [{ label: '结束专注', run: () => stopFocus(false) }] : []),
             ...TOGGLES.map((t) => ({
               label: (cfg[t.key] === true ? '✓ ' : '　') + t.label,
               run: () => applyConfig({ [t.key]: cfg[t.key] !== true }),
@@ -2223,6 +2407,41 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       }
       window.addEventListener('resize', onResize)
 
+      /* ---- 你离开又回来 --------------------------------------------------------
+         visibilitychange 是唯一能知道"你去忙别的了"的信号。离开时长按两个阈值分档：
+         短走一句、长走一句；backAfterMs: 0 就整个关掉。
+         注意监听要能摘掉（destroy 里 remove）—— 文档级监听泄漏过一次，记住这个教训。 */
+      const BACK_LONG_MS = 900000
+      const onVisibility = () => {
+        let state = 'visible'
+        try { state = document.visibilityState === 'hidden' ? 'hidden' : 'visible' } catch (e) { state = 'visible' }
+        if (state === 'hidden') {
+          awayAt = nowMs()
+          /* 没人在看，停掉三个"给看得见的人看"的定时器 */
+          paused = true
+          syncPoll()
+          syncChatter()
+          syncWander()
+          return
+        }
+        /* 回来了：先恢复再算问候 —— 恢复是必须的，问候才是锦上添花 */
+        if (paused) {
+          paused = false
+          syncPoll()
+          syncChatter()
+          syncWander()
+        }
+        if (awayAt === 0) return
+        const away = nowMs() - awayAt
+        awayAt = 0
+        if (!(cfg.backAfterMs > 0) || away < cfg.backAfterMs) return
+        wake(true)
+        say(pick(away >= BACK_LONG_MS ? LINES.backLong : LINES.backSoon))
+      }
+      if (typeof document.addEventListener === 'function') {
+        document.addEventListener('visibilitychange', onVisibility)
+      }
+
       attach()
       /* 打招呼按时段取：凌晨三点和上午十点不该说同一句话。时段在**挂载时**取一次 ——
          一个挂了一整天的页面不该在过零点后突然换口气，那反而像 bug。 */
@@ -2230,6 +2449,17 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       const greetName = greetPoolName(greetHour)
       clock.after(800, () => say(pick(greetPool(greetName))))
 
+      /* 连续天数：第 2 天起才提（第一天说"连续第 1 天"很怪）；到里程碑单独说一句。 */
+      const streak = streakOf(memory.days)
+      if (streak >= 2 && cfg.memory) {
+        const hitMilestone = STREAK_MILESTONES.indexOf(streak) >= 0
+        clock.after(2600, () => {
+          if (destroyed) return
+          const text = pick(hitMilestone ? LINES.milestone : LINES.streak).split('{n}').join(String(streak))
+          flashHappy(text)
+        })
+      }
+
       /* ---- 她更新了吗 --------------------------------------------------------
          插件不能联网，所以"检查更新"它做不了。但**它知道自己现在是哪一版** —— 于是能做到
          一件真事：上次见到的是旧版本，这次不是了，那就是更新过了，说一句。
@@ -2434,6 +2664,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         showUpdate,
         checkForUpdate,
         /* 弹窗与折叠分组：菜单结构变了之后，测试要能问"现在开着哪个弹窗 / 哪个分组"。 */
+        /* 专注计时器：脚本与测试都能驱动 */
+        startFocus,
+        stopFocus,
+        get focus() { return focusState() },
         openAbout: () => aboutDialog(),
         openActions: () => actionsDialog(),
         closeDialog,
@@ -2552,6 +2786,23 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
             },
             /* 干饭：不用猜"她为什么突然捧碗" */
             hunger: { enabled: cfg.hungry === true, everyMs: cfg.hungerMs, lastMealAt: Math.round(lastMealAt) },
+            /* 深夜：窗口是可配的，所以把算出来的窗口一起报出来 */
+            night: {
+              enabled: cfg.night === true,
+              window: [cfg.bedtimeHour, cfg.wakeHour],
+              deepFrom: deepHourOf(cfg.bedtimeHour),
+              hour: hourNow(),
+              lastAt: Math.round(lastNightAt),
+            },
+            streak: streakOf(memory.days),
+            awaySince: Math.round(awayAt),
+            /* 专注：不用猜"她为什么一直站在干活中" */
+            focus: focusState(),
+            /* 定时器是否挂着；页面藏起来时三个都该是 false */
+            timers: {
+              poll: pollHandle !== null, chatter: chatterHandle !== null,
+              wander: wanderHandle !== null, paused,
+            },
             /* 今日轮次：不用猜"她为什么突然得意"，数字就在这里 */
             runsToday: { day: runsToday.day, count: runsToday.count, said: runsToday.said.slice() },
             /* 她记着你：一起多少天、习惯放在哪、常穿哪套、已经说过哪些 */
@@ -2592,6 +2843,9 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           clock.dispose()
           for (const ev of WAKE_EVENTS) window.removeEventListener(ev, wake)
           window.removeEventListener('resize', onResize)
+          if (typeof document.removeEventListener === 'function') {
+            document.removeEventListener('visibilitychange', onVisibility)
+          }
           window.removeEventListener('pointermove', onMove)
           window.removeEventListener('pointerup', onUp)
           bodyEl.removeEventListener('pointerdown', onDown)

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.28.0'
+    const VERSION = '1.30.0'
 
 /* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
    忘了更新就会红，不会静默过期。 */
@@ -69,6 +69,8 @@ const WHATS_NEW = {
   '1.26.0': '检查更新同时读 npm 和 GitHub，取更高的那个版本。',
   '1.27.0': '她饿了会捧出一碗白米饭，还有第八个表情。',
   '1.28.0': '菜单分成折叠分组，另外多了「关于她」和「动作一览」两个弹窗。',
+  '1.29.0': '夜深了她会劝你去睡；你走开再回来她记得；连续来了几天她也记着。',
+  '1.30.0': '会陪你专注计时了；页面藏起来时她会安静下来，不再空转。',
 }
 
 /* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
@@ -164,6 +166,12 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       careAfterMs: 5400000,     // 连续活动这么久之后提醒你起来动动（90 分钟；0 = 关）
       hungry: true,             // 干饭：她饿了会说
       hungerMs: 2700000,        // 连续活动这么久就该吃一碗了（45 分钟；0 = 关）
+      focusMinutes: 25,         // 菜单里「专注 N 分钟」用的默认时长
+      night: true,              // 深夜劝睡
+      bedtimeHour: 23,          // 几点算深夜（0-23）
+      wakeHour: 5,              // 几点算天亮（0-23）；bedtime > wake 时窗口跨零点
+      nightMs: 1800000,         // 深夜每隔这么久说一句（30 分钟；0 = 关）
+      backAfterMs: 120000,      // 离开超过这么久，回来时她会说一句（2 分钟；0 = 关）
       milestones: true,         // 今日轮次到达里程碑时得意一下
       memory: true,             // 她记着你：一起多少天 / 常放哪个角 / 常穿哪套
       happyMs: 1100,
@@ -267,6 +275,44 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
         '算力不够了，得补点碳水。', '电量告急，切待机。', '你要不要也来一口？',
         '这碗不算加餐，算基础设施。', '吃饱了才有力气摸鱼。', '饭碗见底了，该续命了。', '我数着米粒呢。',
       ],
+      /* 专注计时器。她是陪着你干活的，所以"替你画出一段时间的边界"比再多说几句更实在。 */
+      focusStart: [
+        '{n} 分钟。开始吧。', '好，{n} 分钟，我盯着你。', '计时开始，{n} 分钟。', '{n} 分钟不看别的。',
+        '这段时间归你了。{n} 分钟。',
+      ],
+      focusDone: [
+        '{n} 分钟到了。收工。', '{n} 分钟，干完了？', '时间到。{n} 分钟，去喝口水。', '{n} 分钟到了 —— 站起来伸个懒腰。',
+        '这一轮 {n} 分钟，结束了。',
+      ],
+      focusStop: ['行，那就先到这儿。', '不专注了？那我歇着。', '计时取消了。', '好吧，下次再说。'],
+      focusLeft: [
+        '还有 {n} 分钟。', '{n} 分钟，快了。', '还剩 {n} 分钟，别分心。', '还有 {n} 分钟呢，盯着屏幕。',
+      ],
+      /* 深夜劝睡：23 点后一种语气，凌晨 1 点后另一种 —— 后者是社区设定里"嘴硬心软"那一档。
+         分档按 bedtimeHour + 2 推导，所以改了作息这套分档也跟着走。 */
+      nightLate: [
+        '十一点了。', '该收的东西收一收吧。', '我不催你，时钟在催。', '这个点还在跑，明天会还债的。',
+        '夜里的屏幕最亮，眼睛最累。', '再干一会儿就收工？', '白天的你会感谢现在的你。', '我给你留着灯。',
+        '要不要把剩下的留到明天？', '深夜的算力也是算力，但人也得睡。', '我先打个盹，你随意。', '这时候的安静挺值钱的。',
+      ],
+      nightDeep: [
+        '一点了。', '我不管你，但……真的该睡了。', '明天再跑也一样，代码不会跑。', '再撑下去，明天会很难受。',
+        '才不是担心你，只是我不想半夜还看着屏幕。', '你要是倒下，我可没有备份。', '这个点做的决定，白天多半会后悔。',
+        '我数到十你就去睡。……一。', '熬夜是拿明天的算力换今晚的。', '天快亮了，你还在这儿。',
+        '我要是能关灯就好了。', '睡吧。我留在这儿。',
+      ],
+      /* 离开又回来：按走了多久分两档（阈值见 backAfterMs / BACK_LONG_MS）。 */
+      backSoon: [
+        '回来了。', '刚才去哪了。', '我在这儿等着呢。', '一眼没看见你。', '这么快就回来，水都没喝吧。', '位置我没动。',
+      ],
+      backLong: [
+        '你走了好久。', '差点以为今天见不到了。', '回来了就好。', '我一直在这儿。', '这么久，是去吃饭了吗？',
+        '屏幕都凉了。', '我还以为你把我关了。', '下次说一声，我就不数时间了。',
+      ],
+      /* 连续天数（{n} 是天数） */
+      streak: [
+        '连续第 {n} 天了。', '第 {n} 天了，你还在。', '我们已经连着见了 {n} 天。', '第 {n} 天。我记着呢。', '{n} 天没断，挺厉害的。',
+      ],
       updateCurrent: ['已经是最新的了。', '我就是最新的。', '没有更新的。'],
       updateAvailable: ['有新版本了：', '有新版：', '更新来了：'],
       updateFailed: ['更新没查成。', '这次没查到更新。', '更新检查没成功。'],
@@ -283,6 +329,37 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       hint: ['右键我一下试试。', '右键我有菜单。', '拖我，或者右键我。'],
     }
 
+    /* 深夜窗口。bedtime > wake 时它跨零点（默认 23→5）；不跨也能用（比如 1→5）。 */
+    const isNightHour = (hour, from, to) => {
+      if (from === to) return false
+      return from > to ? (hour >= from || hour < to) : (hour >= from && hour < to)
+    }
+    /* "深度深夜"= 已经过了入睡时间两小时以上。按**经过的小时数**算，而不是按绕圈区间：
+       后者在窄窗口（比如 13 点睡、14 点起）会把窗外的一大段时间也算进来。 */
+    const DEEP_AFTER_HOURS = 2
+    const hoursSince = (hour, from) => (((hour - from) % 24) + 24) % 24
+    const deepHourOf = (bedtime) => (Math.round(bedtime) + DEEP_AFTER_HOURS) % 24
+
+    /* 连续天数：从今天往回数，memory.days 里一天不落有多长。
+       用毫秒回推而不是解析日期字符串 —— dayKey() 产出的 2026-9-30 不是 ISO 形式，
+       各引擎对它的解析并不一致。 */
+    const dayKeyOf = (ms) => {
+      try {
+        const d = new Date(ms)
+        return d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate()
+      } catch (e) { return 'unknown' }
+    }
+    const streakOf = (days) => {
+      if (!Array.isArray(days) || days.length === 0) return 0
+      const set = new Set(days)
+      let n = 0
+      let t = Date.now()
+      while (n < 400 && set.has(dayKeyOf(t))) { n++; t -= 86400000 }
+      return n
+    }
+    /* 连续天数的里程碑；到了才说一次。 */
+    const STREAK_MILESTONES = [7, 30, 100, 365]
+
     /* 时段划分：凌晨与白天说话的口气不一样。深夜跨了两天，所以按"< 5 点"算夜里。 */
     const greetPoolName = (hour) => {
       if (hour < 5 || hour >= 22) return 'night'
@@ -337,6 +414,12 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       careAfterMs: { kind: 'num', lo: 0, hi: 86400000 },
       hungry: { kind: 'bool' },
       hungerMs: { kind: 'num', lo: 0, hi: 86400000 },
+      focusMinutes: { kind: 'num', lo: 1, hi: 600 },
+      night: { kind: 'bool' },
+      bedtimeHour: { kind: 'num', lo: 0, hi: 23 },
+      wakeHour: { kind: 'num', lo: 0, hi: 23 },
+      nightMs: { kind: 'num', lo: 0, hi: 86400000 },
+      backAfterMs: { kind: 'num', lo: 0, hi: 86400000 },
       milestones: { kind: 'bool' },
       memory: { kind: 'bool' },
       happyMs: { kind: 'num', lo: 200, hi: 10000 },
@@ -1340,6 +1423,9 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       let lastCareAt = 0
       /* 上一顿饭的时间。起手是 0，所以计时以 activeSince 为准 —— 见下面 mealBase。 */
       let lastMealAt = 0
+      /* 上一次深夜劝睡；离开又回来的时间点。 */
+      let lastNightAt = 0
+      let awayAt = 0
       let happyHandle = null
       let lastErrorCount = 0
 
@@ -1379,6 +1465,18 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         pokedHandle = clock.after(POKED_MS, () => { if (mood === 'poked') setMood('idle') })
       }
 
+      /* 打盹：深夜劝睡用它（一个哈欠比一条通知更像她）。睡着是瞬时状态，
+         自己到期就回稳态。 */
+      const NAP_MS = 5200
+      let napHandle = null
+      const flashSleepy = (text) => {
+        if (mood === 'sleep') wake(true)
+        setMood('sleep')
+        say(text)
+        if (napHandle) clock.cancel(napHandle)
+        napHandle = clock.after(NAP_MS, () => { if (mood === 'sleep') setMood('idle') })
+      }
+
       /* 干饭用的也是瞬时状态（借 eat 的姿态）。比"提醒你活动"长一点 ——
          吃饭本来就慢。 */
       const EAT_MS = 5200
@@ -1480,6 +1578,21 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           flashEat(pick(LINES.eat))
         }
 
+        /* ---- 深夜劝睡 ---------------------------------------------------------
+           作息**是可配的**（bedtimeHour / wakeHour），所以它既是一项真功能，
+           也让测试不必伪造时钟 —— 把窗口套在当前那个小时上就能测。
+           深度深夜从 bedtime + 2 起算，语气换一档：从"该收了"变成"嘴硬心软"。 */
+        if (cfg.night && cfg.nightMs > 0) {
+          const hour = hourNow()
+          const nightBase = Math.max(lastNightAt, activeSince)
+          if (isNightHour(hour, cfg.bedtimeHour, cfg.wakeHour)
+            && nowTick - nightBase >= cfg.nightMs) {
+            lastNightAt = nowTick
+            const deep = hoursSince(hour, cfg.bedtimeHour) >= DEEP_AFTER_HOURS
+            flashSleepy(pick(deep ? LINES.nightDeep : LINES.nightLate))
+          }
+        }
+
         // 有东西在等她处理时，优先级高于一切：这是唯一"你不理它就卡住"的状态。
         const pending = cfg.reactions ? readPending() : null
         if (pending === null) {
@@ -1494,6 +1607,13 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           return
         }
 
+        /* 专注期间不让稳态把她从"干活中"挪走 —— 她在盯着你，这是这个功能的全部意义。
+           位置在这里而不是函数开头：久坐、干饭、劝睡该响还得响。 */
+        if (focusUntil > 0) {
+          if (mood !== 'alert') setMood('alert')
+          return
+        }
+
         // 临时状态（happy / worried）在自己的计时器到期前不能被稳态赋值覆盖 ——
         // 否则刚摆出的表情在同一个 poll 周期里就被 setMood('idle') 抹掉了。
         if (mood === 'sleep' || mood === 'happy' || mood === 'poked' || mood === 'proud' || mood === 'care'
@@ -1503,10 +1623,62 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         setMood((busy || typing) ? 'alert' : 'idle')
       }
 
+      /* ---- 专注计时器 ---------------------------------------------------------
+         桌面陪伴插件最该有的实用功能：替你画出一段时间的边界。
+         专注期间她保持"干活中"的姿势（poll 里给她一个 hold —— 否则稳态会把她挪走），
+         到点收工庆祝；戳她一下就是问"还剩多久"。
+         她**不碰应用**：不改输入框、不发消息，只是陪着 + 计时。 */
+      let focusUntil = 0
+      let focusHandle = null
+      let focusMinutes = 0
+      let focusDone = 0
+
+      const focusLeftMs = () => Math.max(0, focusUntil - nowMs())
+      const focusState = () => (focusUntil > 0
+        ? { active: true, minutes: focusMinutes, leftMs: Math.round(focusLeftMs()), leftMin: Math.max(1, Math.ceil(focusLeftMs() / 60000)), done: focusDone }
+        : { active: false, minutes: 0, leftMs: 0, leftMin: 0, done: focusDone })
+
+      const stopFocus = (silent) => {
+        if (focusUntil === 0 && focusHandle === null) return false
+        focusUntil = 0
+        focusMinutes = 0
+        if (focusHandle) { clock.cancel(focusHandle); focusHandle = null }
+        if (silent !== true) {
+          wake(true)
+          flashHappy(pick(LINES.focusStop))
+        }
+        return true
+      }
+
+      const finishFocus = () => {
+        const minutes = focusMinutes
+        focusUntil = 0
+        focusHandle = null
+        focusMinutes = 0
+        focusDone++
+        wake(true)
+        flashProud(pick(LINES.focusDone).split('{n}').join(String(minutes)))
+      }
+
+      const startFocus = (minutes) => {
+        const mins = clamp(Math.round(Number(minutes) || cfg.focusMinutes), 1, 600)
+        stopFocus(true)
+        focusMinutes = mins
+        focusUntil = nowMs() + mins * 60000
+        wake(true)
+        say(pick(LINES.focusStart).split('{n}').join(String(mins)))
+        focusHandle = clock.after(mins * 60000, () => { if (focusUntil > 0) finishFocus() })
+        return focusState()
+      }
+
+      /* 没人在看的时候别空转：页面藏起来就停掉轮询、絮叨、踱步三个定时器。
+         它们本来就是"给看得见的人看的"，停下来是纯赚（CPU 与电量）。 */
+      let paused = false
+
       let chatterHandle = null
       const syncChatter = () => {
         if (chatterHandle) { clock.cancel(chatterHandle); chatterHandle = null }
-        if (cfg.chatterMs <= 0) return
+        if (cfg.chatterMs <= 0 || paused) return
         chatterHandle = clock.every(cfg.chatterMs, () => {
           if (destroyed || mood !== 'idle') return
           if (agentIsBusy()) return
@@ -1517,7 +1689,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       let pollHandle = null
       const syncPoll = () => {
         if (pollHandle) { clock.cancel(pollHandle); pollHandle = null }
-        if (cfg.reactions) pollHandle = clock.every(POLL_MS, poll)
+        if (cfg.reactions && !paused) pollHandle = clock.every(POLL_MS, poll)
       }
       syncPoll()
       syncChatter()
@@ -1544,7 +1716,7 @@ 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 }
-        if (!cfg.wander || cfg.wanderRange <= 0) return
+        if (!cfg.wander || cfg.wanderRange <= 0 || paused) return
         wanderHandle = clock.every(cfg.wanderMs, () => {
           if (destroyed || hidden || mood !== 'idle' || start !== null) return
           if (agentIsBusy()) return
@@ -1674,6 +1846,12 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (now - pokeWindowStart > POKE_WINDOW_MS) { pokeWindowStart = now; pokeStreak = 0 }
         pokeStreak++
         wake(true)
+        /* 专注中戳她是在问进度，不算戳着玩（也就不会升级成"抗议"）。 */
+        if (focusUntil > 0) {
+          const left = Math.max(1, Math.ceil(focusLeftMs() / 60000))
+          say(pick(LINES.focusLeft).split('{n}').join(String(left)))
+          return
+        }
         if (pokeStreak >= POKE_ANNOYED_AT) {
           pokeStreak = 0
           flashPoked(pick(LINES.poked))
@@ -1798,6 +1976,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         { key: 'reactions', label: '跟随状态' },
         { key: 'celebrate', label: '跑完撒花' },
         { key: 'hungry', label: '饿了会说话' },
+        { key: 'night', label: '深夜劝睡' },
       ]
 
       /* ---- 弹窗 ----------------------------------------------------------------
@@ -1949,6 +2128,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           para('DeepSeek娘 —— DSH 界面上的浮动桌宠。她会跟着你的状态换表情：你打字她在忙，你闲着她在晃，你跑完一轮她替你高兴。'),
           para('她的样子照社区规范来：深蓝色渐变长直发、头顶一个大圆环呆毛、两片鲸鳍耳、女仆装。'),
           para('白米饭是算力的硬通货 —— 所以她每隔一阵会捧碗出来补点碳水。'),
+          para('她还能陪你专注计时：菜单里开一段 25 或 45 分钟，期间她保持"干活中"，戳她一下是问还剩多久，到点她替你收工。'),
           para('这一版：' + (note || VERSION)),
           para('形象与设定参考社区项目 Neko3000/deepseek-whalechan（设定文档 CC BY-NC-SA 4.0，原作者 B站 ZipZipPipe、上善无形）。'),
           dialogFoot('非官方同人作品，与 DeepSeek 官方无关', 'v' + VERSION),
@@ -1980,6 +2160,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           children: [
             { label: '说句话', run: () => { wake(true); say(pick(LINES.click)) } },
             { label: '睡一会儿', run: () => setMood('sleep') },
+            { label: '专注 ' + cfg.focusMinutes + ' 分钟', run: () => startFocus(cfg.focusMinutes) },
+            { label: '专注 45 分钟', run: () => startFocus(45) },
+            /* 只有专注中才出现"结束专注" —— 平时的菜单不该多一个按不动的条目 */
+            ...(focusUntil > 0 ? [{ label: '结束专注', run: () => stopFocus(false) }] : []),
             ...TOGGLES.map((t) => ({
               label: (cfg[t.key] === true ? '✓ ' : '　') + t.label,
               run: () => applyConfig({ [t.key]: cfg[t.key] !== true }),
@@ -2172,6 +2356,41 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       }
       window.addEventListener('resize', onResize)
 
+      /* ---- 你离开又回来 --------------------------------------------------------
+         visibilitychange 是唯一能知道"你去忙别的了"的信号。离开时长按两个阈值分档：
+         短走一句、长走一句；backAfterMs: 0 就整个关掉。
+         注意监听要能摘掉（destroy 里 remove）—— 文档级监听泄漏过一次，记住这个教训。 */
+      const BACK_LONG_MS = 900000
+      const onVisibility = () => {
+        let state = 'visible'
+        try { state = document.visibilityState === 'hidden' ? 'hidden' : 'visible' } catch (e) { state = 'visible' }
+        if (state === 'hidden') {
+          awayAt = nowMs()
+          /* 没人在看，停掉三个"给看得见的人看"的定时器 */
+          paused = true
+          syncPoll()
+          syncChatter()
+          syncWander()
+          return
+        }
+        /* 回来了：先恢复再算问候 —— 恢复是必须的，问候才是锦上添花 */
+        if (paused) {
+          paused = false
+          syncPoll()
+          syncChatter()
+          syncWander()
+        }
+        if (awayAt === 0) return
+        const away = nowMs() - awayAt
+        awayAt = 0
+        if (!(cfg.backAfterMs > 0) || away < cfg.backAfterMs) return
+        wake(true)
+        say(pick(away >= BACK_LONG_MS ? LINES.backLong : LINES.backSoon))
+      }
+      if (typeof document.addEventListener === 'function') {
+        document.addEventListener('visibilitychange', onVisibility)
+      }
+
       attach()
       /* 打招呼按时段取：凌晨三点和上午十点不该说同一句话。时段在**挂载时**取一次 ——
          一个挂了一整天的页面不该在过零点后突然换口气，那反而像 bug。 */
@@ -2179,6 +2398,17 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       const greetName = greetPoolName(greetHour)
       clock.after(800, () => say(pick(greetPool(greetName))))
 
+      /* 连续天数：第 2 天起才提（第一天说"连续第 1 天"很怪）；到里程碑单独说一句。 */
+      const streak = streakOf(memory.days)
+      if (streak >= 2 && cfg.memory) {
+        const hitMilestone = STREAK_MILESTONES.indexOf(streak) >= 0
+        clock.after(2600, () => {
+          if (destroyed) return
+          const text = pick(hitMilestone ? LINES.milestone : LINES.streak).split('{n}').join(String(streak))
+          flashHappy(text)
+        })
+      }
+
       /* ---- 她更新了吗 --------------------------------------------------------
          插件不能联网，所以"检查更新"它做不了。但**它知道自己现在是哪一版** —— 于是能做到
          一件真事：上次见到的是旧版本，这次不是了，那就是更新过了，说一句。
@@ -2383,6 +2613,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         showUpdate,
         checkForUpdate,
         /* 弹窗与折叠分组：菜单结构变了之后，测试要能问"现在开着哪个弹窗 / 哪个分组"。 */
+        /* 专注计时器：脚本与测试都能驱动 */
+        startFocus,
+        stopFocus,
+        get focus() { return focusState() },
         openAbout: () => aboutDialog(),
         openActions: () => actionsDialog(),
         closeDialog,
@@ -2501,6 +2735,23 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
             },
             /* 干饭：不用猜"她为什么突然捧碗" */
             hunger: { enabled: cfg.hungry === true, everyMs: cfg.hungerMs, lastMealAt: Math.round(lastMealAt) },
+            /* 深夜：窗口是可配的，所以把算出来的窗口一起报出来 */
+            night: {
+              enabled: cfg.night === true,
+              window: [cfg.bedtimeHour, cfg.wakeHour],
+              deepFrom: deepHourOf(cfg.bedtimeHour),
+              hour: hourNow(),
+              lastAt: Math.round(lastNightAt),
+            },
+            streak: streakOf(memory.days),
+            awaySince: Math.round(awayAt),
+            /* 专注：不用猜"她为什么一直站在干活中" */
+            focus: focusState(),
+            /* 定时器是否挂着；页面藏起来时三个都该是 false */
+            timers: {
+              poll: pollHandle !== null, chatter: chatterHandle !== null,
+              wander: wanderHandle !== null, paused,
+            },
             /* 今日轮次：不用猜"她为什么突然得意"，数字就在这里 */
             runsToday: { day: runsToday.day, count: runsToday.count, said: runsToday.said.slice() },
             /* 她记着你：一起多少天、习惯放在哪、常穿哪套、已经说过哪些 */
@@ -2541,6 +2792,9 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           clock.dispose()
           for (const ev of WAKE_EVENTS) window.removeEventListener(ev, wake)
           window.removeEventListener('resize', onResize)
+          if (typeof document.removeEventListener === 'function') {
+            document.removeEventListener('visibilitychange', onVisibility)
+          }
           window.removeEventListener('pointermove', onMove)
           window.removeEventListener('pointerup', onUp)
           bodyEl.removeEventListener('pointerdown', onDown)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-wisp",
-  "version": "1.28.0",
+  "version": "1.30.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",

package/verify-wisp.mjs

@@ -320,6 +320,7 @@ function createHarness(options = {}) {
     },
     dispatch(type, event) { for (const fn of [...(documentListeners[type] ?? [])]) fn(event ?? {}) },
     get documentListenerCount() { return Object.values(documentListeners).reduce((n, l) => n + l.length, 0) },
+    documentListenerCountOf(type) { return (documentListeners[type] ?? []).length },
     createElement: (t) => makeEl(t),
     getElementById: (id) => created.find((e) => e.id === id && !e.removed) ?? null,
     /* 采样点上的元素栈：按"最上面优先"返回。窗口背景那一段要靠它判断
@@ -2828,8 +2829,11 @@ head('3y. dialogs: about her, and the action preview')
   dlg.document.dispatch('keydown', { key: 'Escape', preventDefault() {} })
   check(dlgApi.dialog === null && dialogGone(), 'Escape closes it',
     `dialog=${String(dlgApi.dialog)} 监听数=${dlg.document.documentListenerCount}`)
-  check(dlg.document.documentListenerCount === 1,
-    'exactly one document-level key listener exists', String(dlg.document.documentListenerCount))
+  check(dlg.document.documentListenerCountOf('keydown') === 1,
+    'exactly one document-level key listener exists', String(dlg.document.documentListenerCountOf('keydown')))
+  check(dlg.document.documentListenerCountOf('visibilitychange') === 1,
+    'and exactly one visibility listener (added for the come-back greeting)',
+    String(dlg.document.documentListenerCountOf('visibilitychange')))
 
   dlgApi.openActions()
   check(dlgApi.dialog === 'actions', 'the action preview opens', String(dlgApi.dialog))
@@ -2860,8 +2864,9 @@ head('3y. dialogs: about her, and the action preview')
   check(dlgApi.dialog === null, 'clicking the backdrop closes it too')
 
   for (let i = 0; i < 3; i++) { dlgApi.openAbout(); dlgApi.closeDialog() }
-  check(dlg.document.documentListenerCount === 1,
-    'opening and closing repeatedly does not stack listeners', String(dlg.document.documentListenerCount))
+  check(dlg.document.documentListenerCountOf('keydown') === 1,
+    'opening and closing repeatedly does not stack listeners',
+    String(dlg.document.documentListenerCountOf('keydown')))
 
   dlgApi.openAbout()
   dlgApi.destroy()
@@ -2869,6 +2874,325 @@ head('3y. dialogs: about her, and the action preview')
   active = keepDlg
 }
 
+/* ============================== 3y-2. night / come back / streak =========== */
+head('3y-2. night nagging, coming back, and the streak')
+
+/* 这三件事都靠**可配置的时间**，所以不需要伪造时钟：
+   把深夜窗口套在当前那个小时上，行为就该发生；套偏一个小时，就不该发生。 */
+{
+  const hourNowReal = new Date().getHours()
+  const mk = (options) => {
+    const h = createHarness(Object.assign({ timer: true, composerText: '在打字' }, options))
+    h.evaluate(clientSrc)
+    return h
+  }
+  const liveSaid = (h) => h.all('wisp-say').filter((el) => el.removed !== true).map((el) => el.textContent)
+  const saidLines = (h) => liveSaid(h)
+  /* 推进 ms，把过程中出现过的每一句话都收集起来。 */
+  const watch = (h, ms, step = 250) => {
+    const seen = new Set(liveSaid(h))
+    for (let left = ms; left > 0; left -= step) {
+      h.advance(Math.min(step, left), Math.min(step, 200))
+      for (const t of liveSaid(h)) seen.add(t)
+    }
+    return [...seen]
+  }
+  const inPool = (pool, text) => Array.isArray(pool) && pool.includes(text)
+
+  /* ---- 深夜劝睡 ---------------------------------------------------------- */
+  const night = mk()
+  const keepNight = active
+  active = night
+  night.module().default.apply(night.ctx, {
+    reactions: true, wander: false, celebrate: false,
+    careAfterMs: 0, hungerMs: 0, sleepAfterMs: 3600000,
+    /* 让"现在"落在深夜窗口里：从当前小时开始，到下一个小时结束 */
+    bedtimeHour: hourNowReal, wakeHour: (hourNowReal + 1) % 24, nightMs: 60000,
+  })
+  night.advance(1300, 100)
+  const nightApi = night.win.__wisp
+  check(nightApi.doctor().night.enabled === true
+    && nightApi.doctor().night.deepFrom === (hourNowReal + 2) % 24,
+    'doctor reports the night window and where the deeper register starts',
+    JSON.stringify(nightApi.doctor().night))
+  const nightSaid = watch(night, 70000)
+  check(nightSaid.some((t) => inPool(linesInBundle()?.nightLate, t)),
+    'inside the window she speaks up, from the late pool',
+    nightSaid.slice(-2).join(' / ') || '(没说)')
+  check(nightApi.doctor().night.lastAt > 0, 'and the check time is recorded',
+    String(nightApi.doctor().night.lastAt))
+
+  /* 窗口外不该说话 */
+  const day = mk()
+  const keepDay = active
+  active = day
+  day.module().default.apply(day.ctx, {
+    reactions: true, wander: false, celebrate: false,
+    careAfterMs: 0, hungerMs: 0, sleepAfterMs: 3600000,
+    bedtimeHour: (hourNowReal + 3) % 24, wakeHour: (hourNowReal + 4) % 24, nightMs: 60000,
+  })
+  day.advance(1300, 100)
+  const daySaid = watch(day, 200000)
+  check(!daySaid.some((t) => inPool(linesInBundle()?.nightLate, t) || inPool(linesInBundle()?.nightDeep, t)),
+    'outside the window she says nothing about bedtime', saidLines(day).slice(-2).join(' / ') || '(没说)')
+  day.win.__wisp.destroy()
+  active = keepDay
+
+  /* 深度深夜：把 bedtime 往前挪两小时，当前小时就落进"嘴硬心软"那一档 */
+  const deep = mk()
+  const keepDeep = active
+  active = deep
+  deep.module().default.apply(deep.ctx, {
+    reactions: true, wander: false, celebrate: false,
+    careAfterMs: 0, hungerMs: 0, sleepAfterMs: 3600000,
+    bedtimeHour: (hourNowReal + 22) % 24, wakeHour: (hourNowReal + 1) % 24, nightMs: 60000,
+  })
+  deep.advance(1300, 100)
+  const deepSaid = watch(deep, 70000)
+  check(deepSaid.some((t) => inPool(linesInBundle()?.nightDeep, t)),
+    'two hours past bedtime the register changes', deepSaid.slice(-2).join(' / ') || '(没说)')
+
+  /* 两种关法 */
+  const nightLines = () => [].concat(linesInBundle()?.nightLate ?? [], linesInBundle()?.nightDeep ?? [])
+  deep.win.__wisp.configure({ night: false })
+  check(!watch(deep, 300000).some((t) => nightLines().includes(t)),
+    'night: false turns the whole thing off')
+  deep.win.__wisp.configure({ night: true, nightMs: 0 })
+  check(!watch(deep, 300000).some((t) => nightLines().includes(t)), 'so does nightMs: 0')
+  deep.win.__wisp.destroy()
+  active = keepDeep
+
+  /* ---- 离开又回来 -------------------------------------------------------- */
+  const back = mk()
+  const keepBack = active
+  active = back
+  back.module().default.apply(back.ctx, {
+    reactions: true, wander: false, celebrate: false, careAfterMs: 0, hungerMs: 0,
+    sleepAfterMs: 3600000, backAfterMs: 60000,
+  })
+  back.advance(1300, 100)
+  const backApi = back.win.__wisp
+  /* 替身没有 visibilityState，直接摆上再派发事件 —— 这正是真浏览器里发生的事。 */
+  back.document.visibilityState = 'hidden'
+  back.document.dispatch('visibilitychange', {})
+  back.advance(120000, 1000)
+  back.document.visibilityState = 'visible'
+  back.document.dispatch('visibilitychange', {})
+  const shortBack = watch(back, 400)
+  check(shortBack.some((t) => inPool(linesInBundle()?.backSoon, t)),
+    'coming back after a short while gets the short line', shortBack.slice(-2).join(' / ') || '(没说)')
+
+  back.document.visibilityState = 'hidden'
+  back.document.dispatch('visibilitychange', {})
+  back.advance(30 * 60000, 5000)
+  back.document.visibilityState = 'visible'
+  back.document.dispatch('visibilitychange', {})
+  const longBack = watch(back, 400)
+  check(longBack.some((t) => inPool(linesInBundle()?.backLong, t)),
+    'a long absence gets the other line', longBack.slice(-2).join(' / ') || '(没说)')
+
+  /* 走开一小会儿不该说话（只看"回来池"，别把别的行为的话算进来） */
+  const backLines = () => [].concat(linesInBundle()?.backSoon ?? [], linesInBundle()?.backLong ?? [])
+  back.document.visibilityState = 'hidden'
+  back.document.dispatch('visibilitychange', {})
+  back.advance(5000, 1000)
+  back.document.visibilityState = 'visible'
+  back.document.dispatch('visibilitychange', {})
+  check(!watch(back, 600).some((t) => backLines().includes(t)),
+    'a blink of absence is not worth a line')
+
+  back.win.__wisp.configure({ backAfterMs: 0 })
+  back.document.visibilityState = 'hidden'
+  back.document.dispatch('visibilitychange', {})
+  back.advance(30 * 60000, 5000)
+  back.document.visibilityState = 'visible'
+  back.document.dispatch('visibilitychange', {})
+  check(!watch(back, 600).some((t) => backLines().includes(t)),
+    'backAfterMs: 0 turns the greeting off')
+  back.win.__wisp.destroy()
+  active = keepBack
+
+  /* ---- 连续天数 ---------------------------------------------------------- */
+  /* 用 localStorage 直接种一段连续的记录：今天 + 往前三天 = 连续 4 天。 */
+  const keyFor = (offset) => {
+    const d = new Date(Date.now() - offset * 86400000)
+    return d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate()
+  }
+  const memorySeed = {
+    'dsh-wisp:memory:v1': JSON.stringify({
+      days: [keyFor(3), keyFor(2), keyFor(1), keyFor(0)],
+      said: [], corners: {}, skins: {}, remarkDay: keyFor(0),
+    }),
+  }
+  const streak = mk({ storageSeed: memorySeed })
+  const keepStreak = active
+  active = streak
+  streak.module().default.apply(streak.ctx, {
+    reactions: true, wander: false, celebrate: false, careAfterMs: 0, hungerMs: 0, sleepAfterMs: 3600000,
+  })
+  const streakSaid = watch(streak, 5000)
+  const streakApi = streak.win.__wisp
+  check(streakApi.doctor().streak === 4, 'doctor reports a four-day streak', String(streakApi.doctor().streak))
+  const streakPool = [].concat(linesInBundle()?.streak ?? [], linesInBundle()?.milestone ?? [])
+    .map((t) => t.split('{n}').join('4'))
+  check(streakSaid.some((t) => streakPool.includes(t)),
+    'and she mentions it the next time you meet', streakSaid.slice(-3).join(' / ') || '(没说)')
+  streak.win.__wisp.destroy()
+  active = keepStreak
+
+  /* 断了就从头数：今天之前缺一天 */
+  const brokenSeed = {
+    'dsh-wisp:memory:v1': JSON.stringify({
+      days: [keyFor(5), keyFor(4), keyFor(0)], said: [], corners: {}, skins: {}, remarkDay: keyFor(0),
+    }),
+  }
+  const broken = mk({ storageSeed: brokenSeed })
+  const keepBroken = active
+  active = broken
+  broken.module().default.apply(broken.ctx, {
+    reactions: true, wander: false, celebrate: false, careAfterMs: 0, hungerMs: 0, sleepAfterMs: 3600000,
+  })
+  const brokenSaid = watch(broken, 5000)
+  check(broken.win.__wisp.doctor().streak === 1,
+    'a gap resets it to one (and one is not worth mentioning)',
+    String(broken.win.__wisp.doctor().streak))
+  const streakPool2 = [].concat(linesInBundle()?.streak ?? [], linesInBundle()?.milestone ?? [])
+    .map((t) => t.split('{n}').join('1'))
+  check(!brokenSaid.some((t) => streakPool2.includes(t)),
+    'so she stays quiet about it', brokenSaid.slice(-2).join(' / ') || '(没说)')
+  broken.win.__wisp.destroy()
+  active = keepBroken
+}
+
+/* ============================== 3y-3. focus timer & hidden pause ========== */
+head('3y-3. the focus timer, and going quiet while the page is hidden')
+
+{
+  const watch = (h, ms, step = 250) => {
+    const live = () => h.all('wisp-say').filter((el) => el.removed !== true).map((el) => el.textContent)
+    const seen = new Set(live())
+    for (let left = ms; left > 0; left -= step) {
+      h.advance(Math.min(step, left), Math.min(step, 200))
+      for (const t of live()) seen.add(t)
+    }
+    return [...seen]
+  }
+  const strip = (pool, n) => (pool ?? []).map((t) => t.split('{n}').join(String(n)))
+  const moodOf = (h) => h.find('wisp-root').dataset.mood
+
+  /* ---- 专注计时器 -------------------------------------------------------- */
+  const focus = createHarness({ timer: true, composerText: '' })
+  const keepFocus = active
+  active = focus
+  focus.evaluate(clientSrc)
+  focus.module().default.apply(focus.ctx, {
+    reactions: true, wander: false, celebrate: false,
+    careAfterMs: 0, hungerMs: 0, night: false, sleepAfterMs: 3600000,
+  })
+  focus.advance(1300, 100)
+  const focusApi = focus.win.__wisp
+
+  check(focusApi.focus.active === false, 'no focus session at the start')
+  check(focusApi.doctor().focus.active === false && focusApi.doctor().focus.done === 0,
+    'and doctor says so', JSON.stringify(focusApi.doctor().focus))
+
+  const started = focusApi.startFocus(25)
+  check(started.active === true && started.minutes === 25 && started.leftMin === 25,
+    'starting a session reports it back', JSON.stringify(started))
+  check(focusApi.doctor().focus.active === true, 'doctor sees the session too')
+  const startSaid = watch(focus, 1200)
+  check(startSaid.some((t) => strip(linesInBundle()?.focusStart, 25).includes(t)),
+    'and she says the session started', startSaid.slice(-1).join('') || '(没说)')
+
+  /* 专注期间即使她没在忙，姿势也该是"干活中" —— 稳态不许把她挪走 */
+  focus.advance(120000, 5000)
+  check(moodOf(focus) === 'alert', 'she holds the working pose for the whole session', moodOf(focus))
+
+  /* 戳她 = 问还剩多久，而且不算戳着玩 */
+  const pokeOnce = () => {
+    const b = focus.find('wisp-body')
+    b.dispatch('pointerdown', {
+      button: 0, clientX: focusApi.position.x + 260, clientY: focusApi.position.y + 400,
+      preventDefault() {}, stopPropagation() {},
+    })
+    focus.win.dispatch('pointerup', {})
+    focus.advance(200, 50)
+  }
+  /* 24 分钟时戳她 —— 报的应该是"还剩 24 分钟"这类的话 */
+  pokeOnce()
+  const pokeSaid = watch(focus, 800)
+  const leftPool = [].concat(strip(linesInBundle()?.focusLeft, 24), strip(linesInBundle()?.focusLeft, 23))
+  check(pokeSaid.some((t) => leftPool.includes(t)),
+    'poking her during a session asks how long is left', pokeSaid.slice(-2).join(' / ') || '(没说)')
+  check(moodOf(focus) !== 'poked', 'and it does not count as poking for fun', moodOf(focus))
+
+  /* 到点：她说收工，状态回到非激活，计数 +1 */
+  const doneSaid = watch(focus, 26 * 60000, 30000)
+  check(focusApi.focus.active === false, 'the session ends on its own', JSON.stringify(focusApi.focus))
+  check(focusApi.focus.done === 1, 'and the finished count goes up', String(focusApi.focus.done))
+  check(doneSaid.some((t) => strip(linesInBundle()?.focusDone, 25).includes(t)),
+    'and she tells you it is over', doneSaid.slice(-1).join('') || '(没说)')
+
+  /* 参数夹取：0 用默认时长，过大的被夹到 600 */
+  check(focusApi.startFocus(0).minutes === focusApi.config.focusMinutes,
+    'zero falls back to the configured default', String(focusApi.startFocus(0).minutes))
+  check(focusApi.startFocus(9999).minutes === 600, 'an absurd duration is clamped', String(focusApi.focus.minutes))
+  const stopSaid = watch(focus, 400)
+  focusApi.stopFocus()
+  const stopSaid2 = watch(focus, 600)
+  void stopSaid
+  check(focusApi.focus.active === false, 'stopFocus ends it', JSON.stringify(focusApi.focus))
+  check([].concat(stopSaid, stopSaid2).some((t) => (linesInBundle()?.focusStop ?? []).includes(t)),
+    'and she acknowledges the stop', [].concat(stopSaid, stopSaid2).slice(-1).join('') || '(没说)')
+  check(focusApi.stopFocus() === false, 'stopping when nothing is running is a no-op')
+  focus.win.__wisp.destroy()
+  active = keepFocus
+
+  /* ---- 页面藏起来就暂停 -------------------------------------------------- */
+  const quiet = createHarness({ timer: true, composerText: '' })
+  const keepQuiet = active
+  active = quiet
+  quiet.evaluate(clientSrc)
+  quiet.module().default.apply(quiet.ctx, {
+    reactions: true, wander: true, celebrate: false,
+    careAfterMs: 0, hungerMs: 0, night: false, sleepAfterMs: 3600000, backAfterMs: 60000,
+  })
+  quiet.advance(1300, 100)
+  const quietApi = quiet.win.__wisp
+  check(quietApi.doctor().timers.poll === true && quietApi.doctor().timers.paused === false,
+    'while visible the poll is armed', JSON.stringify(quietApi.doctor().timers))
+
+  quiet.document.visibilityState = 'hidden'
+  quiet.document.dispatch('visibilitychange', {})
+  const timers = quietApi.doctor().timers
+  check(timers.paused === true && timers.poll === false && timers.chatter === false && timers.wander === false,
+    'hiding the page stops all three timers', JSON.stringify(timers))
+
+  /* 藏起来期间：来了一堆报错，她也不该有任何反应（轮询停了） */
+  quiet.state.errors = 3
+  quiet.state.busy = true
+  quiet.advance(2000, 500)
+  quiet.state.busy = false
+  quiet.advance(20000, 2000)
+  check(moodOf(quiet) !== 'worried', 'a hidden page gets no reaction at all', moodOf(quiet))
+  check(quiet.all('wisp-say').filter((el) => el.removed !== true).length === 0,
+    'and she stays completely quiet', String(quiet.all('wisp-say').length))
+
+  quiet.document.visibilityState = 'visible'
+  quiet.document.dispatch('visibilitychange', {})
+  const after = quietApi.doctor().timers
+  check(after.paused === false && after.poll === true && after.wander === true,
+    'coming back re-arms them', JSON.stringify(after))
+  /* 回来之后同一批报错就该被看见了 */
+  quiet.state.busy = true
+  quiet.advance(1300, 100)
+  quiet.state.busy = false
+  quiet.advance(3000, 200)
+  check(moodOf(quiet) === 'worried', 'and now the same errors do get a reaction', moodOf(quiet))
+  quiet.win.__wisp.destroy()
+  active = keepQuiet
+}
+
 /* ================================================== 3z. generation audit ==== */
 head('3z. every shipped sprite traces back to a text-only call')