dsh-wisp 1.28.0 → 1.29.0

package/README.md

@@ -448,6 +448,40 @@ node tools/audit-log.mjs --confirm <manifest>     # 生成后：并入代理登
 
 ## 变更
 
+### 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.29.0'
 
 /* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
    忘了更新就会红，不会静默过期。 */
@@ -69,6 +69,7 @@ const WHATS_NEW = {
   '1.26.0': '检查更新同时读 npm 和 GitHub，取更高的那个版本。',
   '1.27.0': '她饿了会捧出一碗白米饭，还有第八个表情。',
   '1.28.0': '菜单分成折叠分组，另外多了「关于她」和「动作一览」两个弹窗。',
+  '1.29.0': '夜深了她会劝你去睡；你走开再回来她记得；连续来了几天她也记着。',
 }
 
 /* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
@@ -215,6 +216,11 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       careAfterMs: 5400000,     // 连续活动这么久之后提醒你起来动动（90 分钟；0 = 关）
       hungry: true,             // 干饭：她饿了会说
       hungerMs: 2700000,        // 连续活动这么久就该吃一碗了（45 分钟；0 = 关）
+      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 +324,31 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
         '算力不够了，得补点碳水。', '电量告急，切待机。', '你要不要也来一口？',
         '这碗不算加餐，算基础设施。', '吃饱了才有力气摸鱼。', '饭碗见底了，该续命了。', '我数着米粒呢。',
       ],
+      /* 深夜劝睡：23 点后一种语气，凌晨 1 点后另一种 —— 后者是社区设定里"嘴硬心软"那一档。
+         分档按 bedtimeHour + 2 推导，所以改了作息这套分档也跟着走。 */
+      nightLate: [
+        '十一点了。', '该收的东西收一收吧。', '我不催你，时钟在催。', '这个点还在跑，明天会还债的。',
+        '夜里的屏幕最亮，眼睛最累。', '再干一会儿就收工？', '白天的你会感谢现在的你。', '我给你留着灯。',
+        '要不要把剩下的留到明天？', '深夜的算力也是算力，但人也得睡。', '我先打个盹，你随意。', '这时候的安静挺值钱的。',
+      ],
+      nightDeep: [
+        '一点了。', '我不管你，但……真的该睡了。', '明天再跑也一样，代码不会跑。', '再撑下去，明天会很难受。',
+        '才不是担心你，只是我不想半夜还看着屏幕。', '你要是倒下，我可没有备份。', '这个点做的决定，白天多半会后悔。',
+        '我数到十你就去睡。……一。', '熬夜是拿明天的算力换今晚的。', '天快亮了，你还在这儿。',
+        '我要是能关灯就好了。', '睡吧。我留在这儿。',
+      ],
+      /* 离开又回来：按走了多久分两档（阈值见 backAfterMs / BACK_LONG_MS）。 */
+      backSoon: [
+        '回来了。', '刚才去哪了。', '我在这儿等着呢。', '一眼没看见你。', '这么快就回来，水都没喝吧。', '位置我没动。',
+      ],
+      backLong: [
+        '你走了好久。', '差点以为今天见不到了。', '回来了就好。', '我一直在这儿。', '这么久，是去吃饭了吗？',
+        '屏幕都凉了。', '我还以为你把我关了。', '下次说一声，我就不数时间了。',
+      ],
+      /* 连续天数（{n} 是天数） */
+      streak: [
+        '连续第 {n} 天了。', '第 {n} 天了，你还在。', '我们已经连着见了 {n} 天。', '第 {n} 天。我记着呢。', '{n} 天没断，挺厉害的。',
+      ],
       updateCurrent: ['已经是最新的了。', '我就是最新的。', '没有更新的。'],
       updateAvailable: ['有新版本了：', '有新版：', '更新来了：'],
       updateFailed: ['更新没查成。', '这次没查到更新。', '更新检查没成功。'],
@@ -334,6 +365,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 +450,11 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       careAfterMs: { kind: 'num', lo: 0, hi: 86400000 },
       hungry: { kind: 'bool' },
       hungerMs: { kind: 'num', lo: 0, hi: 86400000 },
+      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 +1458,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 +1500,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 +1613,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) {
@@ -1849,6 +1946,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: '深夜劝睡' },
       ]
 
       /* ---- 弹窗 ----------------------------------------------------------------
@@ -2223,6 +2321,26 @@ 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(); return }
+        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 +2348,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)
+        })
+      }
+
       /* ---- 她更新了吗 --------------------------------------------------------
          插件不能联网，所以"检查更新"它做不了。但**它知道自己现在是哪一版** —— 于是能做到
          一件真事：上次见到的是旧版本，这次不是了，那就是更新过了，说一句。
@@ -2552,6 +2681,16 @@ 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),
             /* 今日轮次：不用猜"她为什么突然得意"，数字就在这里 */
             runsToday: { day: runsToday.day, count: runsToday.count, said: runsToday.said.slice() },
             /* 她记着你：一起多少天、习惯放在哪、常穿哪套、已经说过哪些 */
@@ -2592,6 +2731,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.29.0'
 
 /* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
    忘了更新就会红，不会静默过期。 */
@@ -69,6 +69,7 @@ const WHATS_NEW = {
   '1.26.0': '检查更新同时读 npm 和 GitHub，取更高的那个版本。',
   '1.27.0': '她饿了会捧出一碗白米饭，还有第八个表情。',
   '1.28.0': '菜单分成折叠分组，另外多了「关于她」和「动作一览」两个弹窗。',
+  '1.29.0': '夜深了她会劝你去睡；你走开再回来她记得；连续来了几天她也记着。',
 }
 
 /* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
@@ -164,6 +165,11 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       careAfterMs: 5400000,     // 连续活动这么久之后提醒你起来动动（90 分钟；0 = 关）
       hungry: true,             // 干饭：她饿了会说
       hungerMs: 2700000,        // 连续活动这么久就该吃一碗了（45 分钟；0 = 关）
+      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 +273,31 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
         '算力不够了，得补点碳水。', '电量告急，切待机。', '你要不要也来一口？',
         '这碗不算加餐，算基础设施。', '吃饱了才有力气摸鱼。', '饭碗见底了，该续命了。', '我数着米粒呢。',
       ],
+      /* 深夜劝睡：23 点后一种语气，凌晨 1 点后另一种 —— 后者是社区设定里"嘴硬心软"那一档。
+         分档按 bedtimeHour + 2 推导，所以改了作息这套分档也跟着走。 */
+      nightLate: [
+        '十一点了。', '该收的东西收一收吧。', '我不催你，时钟在催。', '这个点还在跑，明天会还债的。',
+        '夜里的屏幕最亮，眼睛最累。', '再干一会儿就收工？', '白天的你会感谢现在的你。', '我给你留着灯。',
+        '要不要把剩下的留到明天？', '深夜的算力也是算力，但人也得睡。', '我先打个盹，你随意。', '这时候的安静挺值钱的。',
+      ],
+      nightDeep: [
+        '一点了。', '我不管你，但……真的该睡了。', '明天再跑也一样，代码不会跑。', '再撑下去，明天会很难受。',
+        '才不是担心你，只是我不想半夜还看着屏幕。', '你要是倒下，我可没有备份。', '这个点做的决定，白天多半会后悔。',
+        '我数到十你就去睡。……一。', '熬夜是拿明天的算力换今晚的。', '天快亮了，你还在这儿。',
+        '我要是能关灯就好了。', '睡吧。我留在这儿。',
+      ],
+      /* 离开又回来：按走了多久分两档（阈值见 backAfterMs / BACK_LONG_MS）。 */
+      backSoon: [
+        '回来了。', '刚才去哪了。', '我在这儿等着呢。', '一眼没看见你。', '这么快就回来，水都没喝吧。', '位置我没动。',
+      ],
+      backLong: [
+        '你走了好久。', '差点以为今天见不到了。', '回来了就好。', '我一直在这儿。', '这么久，是去吃饭了吗？',
+        '屏幕都凉了。', '我还以为你把我关了。', '下次说一声，我就不数时间了。',
+      ],
+      /* 连续天数（{n} 是天数） */
+      streak: [
+        '连续第 {n} 天了。', '第 {n} 天了，你还在。', '我们已经连着见了 {n} 天。', '第 {n} 天。我记着呢。', '{n} 天没断，挺厉害的。',
+      ],
       updateCurrent: ['已经是最新的了。', '我就是最新的。', '没有更新的。'],
       updateAvailable: ['有新版本了：', '有新版：', '更新来了：'],
       updateFailed: ['更新没查成。', '这次没查到更新。', '更新检查没成功。'],
@@ -283,6 +314,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 +399,11 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       careAfterMs: { kind: 'num', lo: 0, hi: 86400000 },
       hungry: { kind: 'bool' },
       hungerMs: { kind: 'num', lo: 0, hi: 86400000 },
+      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 +1407,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 +1449,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 +1562,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) {
@@ -1798,6 +1895,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: '深夜劝睡' },
       ]
 
       /* ---- 弹窗 ----------------------------------------------------------------
@@ -2172,6 +2270,26 @@ 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(); return }
+        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 +2297,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)
+        })
+      }
+
       /* ---- 她更新了吗 --------------------------------------------------------
          插件不能联网，所以"检查更新"它做不了。但**它知道自己现在是哪一版** —— 于是能做到
          一件真事：上次见到的是旧版本，这次不是了，那就是更新过了，说一句。
@@ -2501,6 +2630,16 @@ 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),
             /* 今日轮次：不用猜"她为什么突然得意"，数字就在这里 */
             runsToday: { day: runsToday.day, count: runsToday.count, said: runsToday.said.slice() },
             /* 她记着你：一起多少天、习惯放在哪、常穿哪套、已经说过哪些 */
@@ -2541,6 +2680,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.29.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,196 @@ 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
+}
+
 /* ================================================== 3z. generation audit ==== */
 head('3z. every shipped sprite traces back to a text-only call')