dsh-wisp 1.25.1 → 1.27.0

package/lib/client.template.js

@@ -51,7 +51,7 @@ window.__ModuleLoader__.load({
     var exports = module.exports
     Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 
-    const VERSION = '1.25.1'
+    const VERSION = '1.27.0'
 
 /* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
    忘了更新就会红，不会静默过期。 */
@@ -66,6 +66,8 @@ const WHATS_NEW = {
   '1.24.0': '她会报自己的版本，更新过会告诉你，还能把包名复制给你。',
   '1.25.0': '她真的会去查有没有新版本了。',
   '1.25.1': '内容与 1.25.0 相同，重新发布以修好安装源。',
+  '1.26.0': '检查更新同时读 npm 和 GitHub，取更高的那个版本。',
+  '1.27.0': '她饿了会捧出一碗白米饭，还有第八个表情。',
 }
 
 /* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
@@ -159,6 +161,8 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       celebrateAfterMs: 2500,   // ...but only for runs that lasted this long
       chatterMs: 0,             // 0 = she stays quiet when idle
       careAfterMs: 5400000,     // 连续活动这么久之后提醒你起来动动（90 分钟；0 = 关）
+      hungry: true,             // 干饭：她饿了会说
+      hungerMs: 2700000,        // 连续活动这么久就该吃一碗了（45 分钟；0 = 关）
       milestones: true,         // 今日轮次到达里程碑时得意一下
       memory: true,             // 她记着你：一起多少天 / 常放哪个角 / 常穿哪套
       happyMs: 1100,
@@ -254,6 +258,14 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
         '你最近常让我穿{s}。', '{s} —— 你好像挺喜欢这套。', '又是{s}，我都快忘了别的了。',
       ],
       /* 检查更新用的三句。前两句带结果，第三句是"查不了/没查成"。 */
+      /* 干饭。社区给她的设定里，白米饭是算力的唯一硬通货 —— 这是她最像"DeepSeek娘"
+         而不是随便一只桌宠的地方。台词照这个底色写。 */
+      eat: [
+        '白米饭才是硬通货。', '先干一碗，再想复杂的事。', '冰箱里能吃的？那整台冰箱都是我的便当盒。',
+        '才不是特意帮你，只是吃饱了顺手活动一下手指。', '比起深度推理，先来一碗香喷喷的白米饭。',
+        '算力不够了，得补点碳水。', '电量告急，切待机。', '你要不要也来一口？',
+        '这碗不算加餐，算基础设施。', '吃饱了才有力气摸鱼。', '饭碗见底了，该续命了。', '我数着米粒呢。',
+      ],
       updateCurrent: ['已经是最新的了。', '我就是最新的。', '没有更新的。'],
       updateAvailable: ['有新版本了：', '有新版：', '更新来了：'],
       updateFailed: ['更新没查成。', '这次没查到更新。', '更新检查没成功。'],
@@ -322,6 +334,8 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       celebrateAfterMs: { kind: 'num', lo: 0, hi: 600000 },
       chatterMs: { kind: 'num', lo: 0, hi: 3600000 },
       careAfterMs: { kind: 'num', lo: 0, hi: 86400000 },
+      hungry: { kind: 'bool' },
+      hungerMs: { kind: 'num', lo: 0, hi: 86400000 },
       milestones: { kind: 'bool' },
       memory: { kind: 'bool' },
       happyMs: { kind: 'num', lo: 200, hi: 10000 },
@@ -1080,7 +1094,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       /* ---- 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_OF = { idle: 'idle', alert: 'work', happy: 'happy', sleep: 'sleepy', attn: 'attn', care: 'attn', poked: 'poked', proud: 'proud', worried: 'sleepy', eat: 'eat' }
       const SPRITE_FALLBACK = { attn: 'work' }
       let mood = 'idle'
 
@@ -1294,6 +1308,8 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       let activeSince = 0
       let lastActiveAt = 0
       let lastCareAt = 0
+      /* 上一顿饭的时间。起手是 0，所以计时以 activeSince 为准 —— 见下面 mealBase。 */
+      let lastMealAt = 0
       let happyHandle = null
       let lastErrorCount = 0
 
@@ -1333,6 +1349,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') })
       }
 
+      /* 干饭用的也是瞬时状态（借 eat 的姿态）。比"提醒你活动"长一点 ——
+         吃饭本来就慢。 */
+      const EAT_MS = 5200
+      let eatHandle = null
+      const flashEat = (text) => {
+        if (mood === 'sleep') wake(true)
+        setMood('eat')
+        say(text)
+        if (eatHandle) clock.cancel(eatHandle)
+        eatHandle = clock.after(EAT_MS, () => { if (mood === 'eat') setMood('idle') })
+      }
+
       /* 久坐提醒用的也是一个**瞬时状态**（借 attn 的姿态），理由和 poked 一样：
          稳态逻辑每轮都会重算，不给它自己的定时器就会被抹掉。 */
       const PROUD_MS = 2800
@@ -1409,6 +1437,19 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           flashCare(pick(LINES.care))
         }
 
+        /* ---- 干饭 -------------------------------------------------------------
+           和久坐共用同一套"还在动"的判定，但含义相反：久坐是提醒你起来，
+           干饭是提醒她自己该补碳了。计时基准取 lastMealAt 与 activeSince 里更晚的那个 ——
+           离开很久回来之后，不该立刻就说饿（那一段已经结束了）。 */
+        const mealBase = Math.max(lastMealAt, activeSince)
+        if (
+          cfg.hungry && cfg.hungerMs > 0 && activeSince !== 0
+          && nowTick - mealBase >= cfg.hungerMs
+        ) {
+          lastMealAt = nowTick
+          flashEat(pick(LINES.eat))
+        }
+
         // 有东西在等她处理时，优先级高于一切：这是唯一"你不理它就卡住"的状态。
         const pending = cfg.reactions ? readPending() : null
         if (pending === null) {
@@ -1425,7 +1466,8 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 
         // 临时状态（happy / worried）在自己的计时器到期前不能被稳态赋值覆盖 ——
         // 否则刚摆出的表情在同一个 poll 周期里就被 setMood('idle') 抹掉了。
-        if (mood === 'sleep' || mood === 'happy' || mood === 'poked' || mood === 'proud' || mood === 'care' || mood === 'worried') return
+        if (mood === 'sleep' || mood === 'happy' || mood === 'poked' || mood === 'proud' || mood === 'care'
+          || mood === 'eat' || mood === 'worried') return
         setMood((busy || typing) ? 'alert' : 'idle')
       }
 
@@ -1720,6 +1762,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         { key: 'wander', label: '自己溜达' },
         { key: 'reactions', label: '跟随状态' },
         { key: 'celebrate', label: '跑完撒花' },
+        { key: 'hungry', label: '饿了会说话' },
       ]
 
       const menuItems = () => {
@@ -2005,9 +2048,11 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
             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() }
+              /* from / sources 一起留着：两个源不一致时（npm 暂存、GitHub 已更新），
+                 "这个数字是哪儿来的"比数字本身更需要能查。 */
+              updateCheck = { state: 'available', latest: res.latest, from: res.from ?? null, sources: res.sources ?? null, at: nowMs() }
             } else {
-              updateCheck = { state: 'current', latest: res.latest, at: nowMs() }
+              updateCheck = { state: 'current', latest: res.latest, from: res.from ?? null, sources: res.sources ?? null, at: nowMs() }
             }
             return updateCheck
           })
@@ -2195,6 +2240,8 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
               lastCheck: { ...updateCheck },
               why: '宿主半包在 vm 沙箱里，harness 只有 defineTool/registerTool/handle，Node API 被 nodeApiTraps 挡住',
             },
+            /* 干饭：不用猜"她为什么突然捧碗" */
+            hunger: { enabled: cfg.hungry === true, everyMs: cfg.hungerMs, lastMealAt: Math.round(lastMealAt) },
             /* 今日轮次：不用猜"她为什么突然得意"，数字就在这里 */
             runsToday: { day: runsToday.day, count: runsToday.count, said: runsToday.said.slice() },
             /* 她记着你：一起多少天、习惯放在哪、常穿哪套、已经说过哪些 */

package/lib/index.js

@@ -13,6 +13,14 @@
 //   2. Nothing else. `web` is declared as an OPTIONAL inject on purpose: a
 //      required inject that nothing provides would leave this fiber `waiting`
 //      forever, and the companion would simply disappear from the UI.
+//
+// WHY TWO SOURCES. npm's registry is the authoritative one, but a publish can sit
+// in npm's staging queue for a long time (observed: `PUT 202`, still 404 after 18
+// minutes, and re-publishing the same version is refused with 409). GitHub's raw
+// manifest updated immediately in the same situation. So the check reads BOTH and
+// reports the HIGHER version — which is correct whether or not npm has caught up.
+// "npm first, GitHub as fallback" would read the stale npm number and claim you
+// were up to date.
 
 /** Cordis plugin name used by loader diagnostics. */
 export const name = 'wisp'
@@ -23,42 +31,43 @@ export const name = 'wisp'
  */
 export const inject = { required: [], optional: ['web'] }
 
-/** Where the check reads the published version from. Overridable per install. */
-export const DEFAULT_UPDATE_URL = 'https://raw.githubusercontent.com/969246694/dsh-wisp/main/package.json'
+/** The two places a published version can be read from. Overridable per install. */
+export const DEFAULT_SOURCES = {
+  npm: 'https://registry.npmjs.org/dsh-wisp/latest',
+  github: 'https://raw.githubusercontent.com/969246694/dsh-wisp/main/package.json',
+}
 
-/** How long a check may take before it is reported as a timeout. */
+/** How long the whole check may take before it is reported as a timeout. */
 const CHECK_TIMEOUT_MS = 8000
 
 /**
- * Fetch the published package.json and pull `version` out of it.
+ * Fetch one manifest and pull `version` out of it.
  * @param web - the `web` service, or undefined when it is not loaded.
  * @param url - the manifest URL.
  * @param signal - optional cancellation signal.
- * @returns a plain, JSON-serializable verdict (this crosses the sandbox boundary).
+ * @returns `{ ok, version }` or `{ ok: false, reason }` — never throws.
  */
-export async function readPublishedVersion(web, url, signal) {
-  if (!web || typeof web.fetch !== 'function') {
-    return { ok: false, reason: 'no-web-service', url }
-  }
+export async function readVersion(web, url, signal) {
+  if (!web || typeof web.fetch !== 'function') return { ok: false, reason: 'no-web-service' }
   try {
     const res = await web.fetch({ url }, signal)
-    if (!res || typeof res.statusCode !== 'number') return { ok: false, reason: 'bad-result', url }
+    if (!res || typeof res.statusCode !== 'number') return { ok: false, reason: 'bad-result' }
     /* Per the service contract a non-2xx response is a RESULT, not a throw —
        so the status must be checked here instead of caught below. */
-    if (res.statusCode !== 200) return { ok: false, reason: 'http-' + res.statusCode, url }
+    if (res.statusCode !== 200) return { ok: false, reason: 'http-' + res.statusCode }
     const text = res.body && typeof res.body.content === 'string' ? res.body.content : ''
-    let latest = null
+    let version = null
     try {
       const parsed = JSON.parse(text)
-      if (parsed && typeof parsed.version === 'string') latest = parsed.version
+      if (parsed && typeof parsed.version === 'string') version = parsed.version
     } catch (error) {
-      return { ok: false, reason: 'not-json', url }
+      return { ok: false, reason: 'not-json' }
     }
-    if (latest === null) return { ok: false, reason: 'no-version-field', url }
-    return { ok: true, url, latest }
+    if (version === null) return { ok: false, reason: 'no-version-field' }
+    return { ok: true, version }
   } catch (error) {
     const detail = error && error.message ? String(error.message) : String(error)
-    return { ok: false, reason: 'fetch-failed', detail, url }
+    return { ok: false, reason: 'fetch-failed', detail }
   }
 }
 
@@ -78,11 +87,41 @@ export function compareVersions(a, b) {
   return 0
 }
 
+/**
+ * Read every source and report the highest version found.
+ * @param web - the `web` service.
+ * @param urls - `{ npm, github }` (or any other set of named sources).
+ * @param signal - optional cancellation signal.
+ * @returns a plain, JSON-serializable verdict (it crosses the sandbox boundary).
+ */
+export async function readPublishedVersion(web, urls, signal) {
+  const names = Object.keys(urls ?? {})
+  const results = await Promise.all(names.map((key) => readVersion(web, urls[key], signal)))
+  const sources = {}
+  let best = null
+  let from = null
+  let anyOk = false
+  names.forEach((key, i) => {
+    const r = results[i]
+    sources[key] = r.ok ? { ok: true, version: r.version } : { ok: false, reason: r.reason, detail: r.detail }
+    if (!r.ok) return
+    anyOk = true
+    /* The HIGHER version wins, so a stale mirror cannot mask a newer release. */
+    if (best === null || compareVersions(best, r.version) < 0) {
+      best = r.version
+      from = key
+    }
+  })
+  if (!anyOk) {
+    const first = results.find((r) => r && !r.ok)
+    return { ok: false, reason: first ? first.reason : 'no-sources', sources }
+  }
+  return { ok: true, latest: best, from, sources }
+}
+
 /** Register the handler the browser half reaches through `host.call`. */
 export function registerHandlers(ctx, options = {}) {
-  const url = typeof options.updateUrl === 'string' && options.updateUrl !== ''
-    ? options.updateUrl
-    : DEFAULT_UPDATE_URL
+  const urls = options.urls && typeof options.urls === 'object' ? options.urls : DEFAULT_SOURCES
   /* `harness` is a sandbox global: the host half is evaluated inside a vm whose
      context carries it. Guard the reference so this module also loads — and is
      testable — outside that sandbox. */
@@ -99,13 +138,13 @@ export function registerHandlers(ctx, options = {}) {
       timer = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS)
     }
     try {
-      const verdict = await readPublishedVersion(ctx && ctx.web, url, controller ? controller.signal : undefined)
+      const verdict = await readPublishedVersion(ctx && ctx.web, urls, controller ? controller.signal : undefined)
       return { ...verdict, current, checkedAt: new Date().toISOString() }
     } finally {
       if (timer !== null && typeof clearTimeout === 'function') clearTimeout(timer)
     }
   })
-  return { registered: true, dispose, url }
+  return { registered: true, dispose, urls }
 }
 
 export function apply(ctx, config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-wisp",
-  "version": "1.25.1",
+  "version": "1.27.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/tools/assets.mjs

@@ -45,7 +45,7 @@ const flag = (name, fallback) => {
   const at = argv.indexOf(name)
   return at >= 0 && argv[at + 1] !== undefined ? argv[at + 1] : fallback
 }
-const MOODS = ['idle', 'happy', 'sleepy', 'work', 'attn', 'poked', 'proud']
+const MOODS = ['idle', 'happy', 'sleepy', 'work', 'attn', 'poked', 'proud', 'eat']
 const srcDir = resolve(here, flag('--from', 'masters'))
 /* 皮肤 = assets/ 下的一个子目录。--skin 决定输出到哪一套。
    注意 build.mjs 会把每个子目录当成一套皮肤打进包里，所以皮肤越多包越大。 */

package/tools/smoke.mjs

@@ -232,15 +232,15 @@ check(cornerMenu !== null && cornerMenu.inside,
   cornerMenu ? `bottom ${cornerMenu.bottom} (was ${cornerMenu.naiveBottom}), right ${cornerMenu.right}` : 'n/a')
 
 const menu = await openMenu()
-// 项数从皮肤数推导（13 项固定 + 每套皮肤一项），不写死：加一套皮肤不该让测试变红 ——
+// 项数从皮肤数推导（14 项固定 + 每套皮肤一项），不写死：加一套皮肤不该让测试变红 ——
 // 那是数据的错，不是行为的错。
 // api.skins 是**数组**；用 Object.keys 数数组只是碰巧数对（预检里踩过这个坑，这里一并对齐）。
 const skinCount = await page.evaluate(() => {
   const s = window.__wisp.skins
   return Array.isArray(s) ? s.length : Object.keys(s ?? {}).length
 })
-check(menu !== null && menu.items.length === 13 + skinCount, 'the menu lists every entry',
-  `${menu?.items.length} items = 13 + ${skinCount} skin(s)`)
+check(menu !== null && menu.items.length === 14 + skinCount, 'the menu lists every entry',
+  `${menu?.items.length} items = 14 + ${skinCount} skin(s)`)
 
 // 键盘：打开即聚焦第一项，方向键移动，Esc 关闭并把焦点还给她
 const kbd = await page.evaluate(() => {

package/verify-wisp.mjs

@@ -531,8 +531,10 @@ head('1b. the host half answers checkUpdate through the platform web service')
   check(Boolean(declaresWeb) && Array.isArray(inject.required) && !inject.required.includes('web'),
     'and not as a required one — a missing service must not hide her', JSON.stringify(inject))
 
-  const fakeWeb = (outcome) => ({
+  /* 每个 URL 一个态度：可以按 URL 给不同的结果，才能测"两个源"的组合。 */
+  const webWith = (byUrl) => ({
     fetch: async (request) => {
+      const outcome = byUrl[request.url] ?? { status: 404, body: 'nope' }
       if (outcome.throw) throw new Error(outcome.throw)
       return {
         url: request.url,
@@ -542,29 +544,69 @@ head('1b. the host half answers checkUpdate through the platform web service')
       }
     },
   })
+  const U = { npm: 'https://npm/x', github: 'https://gh/y' }
+  const only = (key, outcome) => webWith({ [U[key]]: outcome })
 
-  const good = await readPublishedVersion(fakeWeb({ body: '{"name":"dsh-wisp","version":"9.9.9"}' }), 'https://x/y')
-  check(good.ok === true && good.latest === '9.9.9', 'a 200 with a version field is read correctly', JSON.stringify(good))
+  const good = await readPublishedVersion(only('npm', { body: '{"name":"dsh-wisp","version":"9.9.9"}' }), U)
+  check(good.ok === true && good.latest === '9.9.9' && good.from === 'npm',
+    'a 200 with a version field is read correctly', JSON.stringify(good))
 
-  const notFound = await readPublishedVersion(fakeWeb({ status: 404, body: 'nope' }), 'https://x/y')
+  const notFound = await readPublishedVersion(only('npm', { status: 404, body: 'nope' }), U)
   check(notFound.ok === false && notFound.reason === 'http-404',
     'a non-2xx is a result, not a throw — and is reported as such', JSON.stringify(notFound))
 
-  const noWeb = await readPublishedVersion(undefined, 'https://x/y')
+  const noWeb = await readPublishedVersion(undefined, U)
   check(noWeb.ok === false && noWeb.reason === 'no-web-service',
     'without the web service it says so instead of throwing', JSON.stringify(noWeb))
 
-  const blewUp = await readPublishedVersion(fakeWeb({ throw: 'socket closed' }), 'https://x/y')
-  check(blewUp.ok === false && blewUp.reason === 'fetch-failed' && blewUp.detail === 'socket closed',
+  const blewUp = await readPublishedVersion(only('npm', { throw: 'socket closed' }), U)
+  check(blewUp.ok === false && blewUp.reason === 'fetch-failed',
     'a transport failure is caught and reported', JSON.stringify(blewUp))
 
-  const notJson = await readPublishedVersion(fakeWeb({ body: '<html>404</html>' }), 'https://x/y')
+  const notJson = await readPublishedVersion(only('npm', { body: '<html>404</html>' }), U)
   check(notJson.ok === false && notJson.reason === 'not-json', 'a non-JSON body is reported', JSON.stringify(notJson))
 
-  const noField = await readPublishedVersion(fakeWeb({ body: '{"name":"dsh-wisp"}' }), 'https://x/y')
+  const noField = await readPublishedVersion(only('npm', { body: '{"name":"dsh-wisp"}' }), U)
   check(noField.ok === false && noField.reason === 'no-version-field',
     'a manifest without a version is reported', JSON.stringify(noField))
 
+  /* ---- 两个源：取更高的那个，而不是"谁先谁赢" ---- */
+  const bothAgree = await readPublishedVersion(webWith({
+    [U.npm]: { body: '{"version":"1.25.1"}' },
+    [U.github]: { body: '{"version":"1.25.1"}' },
+  }), U)
+  check(bothAgree.ok === true && bothAgree.latest === '1.25.1',
+    'when both sources agree the answer is that version', JSON.stringify(bothAgree))
+  check(bothAgree.sources.npm.ok === true && bothAgree.sources.github.ok === true,
+    'and both sources are reported individually', JSON.stringify(bothAgree.sources))
+
+  /* 真实情况：npm 卡在旧的 0.6.0，GitHub 已经是 1.25.1 —— 必须报 1.25.1 */
+  const staleNpm = await readPublishedVersion(webWith({
+    [U.npm]: { body: '{"version":"0.6.0"}' },
+    [U.github]: { body: '{"version":"1.25.1"}' },
+  }), U)
+  check(staleNpm.ok === true && staleNpm.latest === '1.25.1' && staleNpm.from === 'github',
+    'a stale npm cannot mask a newer GitHub release', JSON.stringify(staleNpm))
+
+  /* 反过来也一样：npm 更新时必须报 npm 那个 */
+  const newerNpm = await readPublishedVersion(webWith({
+    [U.npm]: { body: '{"version":"2.0.0"}' },
+    [U.github]: { body: '{"version":"1.25.1"}' },
+  }), U)
+  check(newerNpm.ok === true && newerNpm.latest === '2.0.0' && newerNpm.from === 'npm',
+    'and a newer npm wins over an older GitHub', JSON.stringify(newerNpm))
+
+  /* 一个挂了、另一个还在：仍然要有答案，并且说清哪个挂了 */
+  const oneDown = await readPublishedVersion(webWith({
+    [U.github]: { body: '{"version":"1.25.1"}' },
+  }), U)
+  check(oneDown.ok === true && oneDown.latest === '1.25.1' && oneDown.sources.npm.ok === false,
+    'one dead source does not break the check', JSON.stringify(oneDown))
+
+  const bothDown = await readPublishedVersion(webWith({ [U.npm]: { throw: 'x' } }), U)
+  check(bothDown.ok === false && bothDown.sources.npm.ok === false && bothDown.sources.github.ok === false,
+    'when every source fails the check fails — with per-source reasons', JSON.stringify(bothDown))
+
   check(compareVersions('1.2.3', '1.2.4') === -1 && compareVersions('1.2.3', '1.2.3') === 0
     && compareVersions('1.3.0', '1.2.9') === 1, 'version comparison is numeric, not lexicographic',
     `${compareVersions('1.10.0', '1.9.0')} for 1.10.0 vs 1.9.0`)
@@ -573,16 +615,17 @@ head('1b. the host half answers checkUpdate through the platform web service')
   const previousSeat = globalThis.harness
   const handlers = new Map()
   globalThis.harness = { handle: (method, fn) => { handlers.set(method, fn); return () => handlers.delete(method) } }
-  const registered = registerHandlers({ web: fakeWeb({ body: '{"version":"9.9.9"}' }) }, {})
+  const registered = registerHandlers({ web: only('npm', { body: '{"version":"9.9.9"}' }) }, { urls: U })
   check(registered.registered === true && handlers.has('checkUpdate'),
     'registerHandlers puts checkUpdate on the harness seat', JSON.stringify({ registered: registered.registered }))
   const answer = await handlers.get('checkUpdate')({ current: '1.0.0' })
   check(answer.ok === true && answer.latest === '9.9.9' && answer.current === '1.0.0'
     && typeof answer.checkedAt === 'string',
     'the handler returns a plain, serializable verdict', JSON.stringify(answer))
-  const injectedUrl = handlers.size > 0 ? registered.url : null
-  check(typeof injectedUrl === 'string' && injectedUrl.startsWith('https://'),
-    'and it reads from a real https manifest URL', String(injectedUrl))
+  const urls = registered.urls ?? {}
+  check(typeof urls.npm === 'string' && urls.npm.startsWith('https://')
+    && typeof urls.github === 'string' && urls.github.startsWith('https://'),
+    'and it reads from two real https sources', JSON.stringify(urls))
 
   /* 座位不在时不许抛：宿主半包在别的运行时里也要能 import */
   delete globalThis.harness
@@ -596,7 +639,7 @@ head('1b. the host half answers checkUpdate through the platform web service')
   const effects = []
   let appliedThrew = false
   try {
-    mod.apply({ web: fakeWeb({ body: '{"version":"9.9.9"}' }), effect: (fn, label) => { effects.push(label); return () => {} } }, {})
+    mod.apply({ web: only('npm', { body: '{"version":"9.9.9"}' }), effect: (fn, label) => { effects.push(label); return () => {} } }, {})
   } catch (error) { appliedThrew = true }
   check(appliedThrew === false && handlers.has('checkUpdate') && effects.length === 1,
     'apply() registers the handler and keeps its disposer on the fiber', effects.join(', '))
@@ -1307,6 +1350,128 @@ if (clientSrc !== null) {
     care.win.__wisp.destroy()
     active = keepCare
 
+    /* ---------------- 3d-octodecies. 干饭 ----------------------------------- */
+    head('3d-octodecies. she gets hungry and says so (the rice thing)')
+
+    /* 这是社区的设定里最像"她"的一条：白米饭是算力的硬通货。行为本身很简单 ——
+       连续活动够久就该吃一碗 —— 但要测的是**判据**：别一回来就喊饿、别连着喊、
+       能关掉。careAfterMs 关掉，免得住坐提醒和它互相干扰。 */
+    const eat = createHarness({ timer: true, composerText: '在打字' })
+    const keepEat = active
+    active = eat
+    eat.evaluate(clientSrc)
+    eat.module().default.apply(eat.ctx, {
+      reactions: true, wander: false, celebrate: false,
+      careAfterMs: 0, hungerMs: 600000, sleepAfterMs: 3600000,
+    })
+    eat.advance(1300, 100)
+    const eatApi = eat.win.__wisp
+    const eatMood = () => eat.find('wisp-root').dataset.mood
+    const eatUntil = (limitMs, chunk = 1000) => {
+      for (let left = limitMs; left > 0; left -= chunk) {
+        eat.advance(Math.min(chunk, left), 200)
+        if (eatMood() === 'eat') return true
+      }
+      return false
+    }
+    const bubbleIsEat = () => {
+      const text = eat.all('wisp-say').at(-1)?.textContent
+      return Array.isArray(linesInBundle()?.eat) && linesInBundle().eat.includes(text)
+    }
+
+    check(Array.isArray(linesInBundle()?.eat) && linesInBundle().eat.length >= 8,
+      'the rice pool exists and has some lines in it', `${linesInBundle()?.eat?.length ?? '?'} 句`)
+    check(eatApi.doctor().hunger.enabled === true && eatApi.doctor().hunger.everyMs === 600000,
+      'doctor reports the hunger setting', JSON.stringify(eatApi.doctor().hunger))
+
+    // 9 分钟：还没到
+    let sawEarlyEat = false
+    for (let left = 9 * 60000; left > 0; left -= 1000) {
+      eat.advance(1000, 200)
+      if (eatMood() === 'eat') { sawEarlyEat = true; break }
+    }
+    check(!sawEarlyEat, 'nine minutes in she is not hungry yet', eatMood())
+
+    check(eatUntil(200000), 'past the threshold she gets a bowl out')
+    check(bubbleIsEat(), 'and the line comes from the rice pool',
+      (eat.all('wisp-say').at(-1)?.textContent ?? '(无)'))
+    check(eatMood() === 'eat' && eatApi.currentMood === 'eat',
+      'and both the DOM and the reported mood say eat', `${eatMood()} / ${eatApi.currentMood}`)
+
+    // 稳态轮询不能把它抹掉
+    eat.advance(1000, 100)
+    check(eatMood() === 'eat', 'the reaction poll does not overwrite the meal', eatMood())
+
+    // 吃完自己回去（EAT_MS = 5.2 秒）
+    for (let left = 8000; left > 0; left -= 500) eat.advance(500, 100)
+    check(eatMood() === 'alert', 'and the meal ends on its own, back to alert', eatMood())
+
+    // 不该连着说
+    let saidAgain = false
+    for (let left = 60000; left > 0; left -= 1000) {
+      eat.advance(1000, 200)
+      if (eatMood() === 'eat') { saidAgain = true; break }
+    }
+    check(!saidAgain, 'she does not ask for rice again a minute later', eatMood())
+    check(eatUntil(600000), 'but another full stretch does bring it back')
+
+    // 离开很久之后回来：不该一进门就喊饿
+    eat.win.__wisp.configure({ hungerMs: 300000 })
+    eat.state.composerText = null
+    eat.advance(20 * 60000, 5000)
+    eat.state.composerText = '回来了'
+    eat.advance(1300, 100)
+    let instantHunger = false
+    for (let left = 120000; left > 0; left -= 1000) {
+      eat.advance(1000, 200)
+      if (eatMood() === 'eat') { instantHunger = true; break }
+    }
+    check(!instantHunger, 'after a long absence she does not ask for rice the moment you return', eatMood())
+    check(eatUntil(300000), 'only a fresh full stretch makes her hungry')
+    /* 让这一顿吃完（EAT_MS = 5.2 秒）再测关闭 —— 否则"还停在 eat"会被误判成"关不掉"。
+       （这个坑久坐提醒那节也踩过，同样用一段推进收尾。） */
+    eat.advance(8000, 500)
+
+    // 关掉这个行为（两种关法）
+    eat.win.__wisp.configure({ hungerMs: 0 })
+    let offByZero = false
+    for (let left = 20 * 60000; left > 0; left -= 5000) {
+      eat.advance(5000, 500)
+      if (eatMood() === 'eat') { offByZero = true; break }
+    }
+    check(!offByZero, 'hungerMs: 0 turns it off', eatMood())
+    eat.win.__wisp.configure({ hungerMs: 300000, hungry: false })
+    let offByFlag = false
+    for (let left = 20 * 60000; left > 0; left -= 5000) {
+      eat.advance(5000, 500)
+      if (eatMood() === 'eat') { offByFlag = true; break }
+    }
+    check(!offByFlag, 'and hungry: false turns it off even with a live timer', eatMood())
+    check(eatApi.config.hungry === false, 'and the config says so', String(eatApi.config.hungry))
+
+    // 菜单开关：先把菜单叫出来（菜单项是开菜单时才建的），点一下就该翻转
+    /* 主菜单的入口是 .wisp-body 上的 keydown（Enter / 空格 / ContextMenu / Shift+F10），
+       不是 contextmenu —— 后者只挂在"躲起来"之后的迷你标签上。事件对象同样自建：
+       ctxEvent 定义在文件后半部分，在这里用就是 TDZ。 */
+    eat.win.__wisp.configure({ hungry: true })
+    const eatBody = eat.find('wisp-root').querySelector('.wisp-body')
+    eatBody.dispatch('keydown', {
+      type: 'keydown', key: 'Enter', shiftKey: false, defaultPrevented: false,
+      preventDefault() { this.defaultPrevented = true }, stopPropagation() {},
+    })
+    const eatToggle = eat.all('wisp-menu-item').filter((el) => el.removed !== true)
+      .find((el) => (el.textContent || '').includes('饿了'))
+    check(Boolean(eatToggle), 'the menu carries a rice toggle',
+      eat.all('wisp-menu-item').filter((el) => el.removed !== true).length + ' 项')
+    if (eatToggle) {
+      /* 元素上的点击走 harness 的 dispatch(type, event) —— 不是浏览器的 dispatchEvent（没有那个方法）。 */
+      eatToggle.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+      check(eat.win.__wisp.config.hungry === false, 'and clicking it turns the behaviour off',
+        String(eat.win.__wisp.config.hungry))
+    }
+    eat.win.__wisp.destroy()
+    active = keepEat
+
     /* 睡着了也得被叫醒：这条单独测，因为它需要 sleepAfterMs 很短 */
     const sleepCare = createHarness({ timer: true, composerText: '在打字' })
     const keepSleepCare = active
@@ -2075,12 +2240,12 @@ if (clientSrc !== null) {
     check(menuOf() !== null, 'the right-click opens a context menu')
     check(menuOf()?.getAttribute('role') === 'menu', 'the menu carries menu semantics')
     /* 项数从皮肤数**推导**，不写死：加一套皮肤不该让测试变红（那是数据的错，不是行为的错）。
-       固定部分 = 6 个动作 + 3 个开关 + 4 个角落 = 13；其余是每套皮肤一项。 */
+       固定部分 = 6 个动作 + 4 个开关 + 4 个角落 = 14；其余是每套皮肤一项。 */
     /* api.skins 是数组（SKIN_IDS 的拷贝），不是对象 —— 用 Object.keys 只是碰巧数对了。 */
     const skinCount = Array.isArray(api.skins) ? api.skins.length : Object.keys(api.skins ?? {}).length
-    check(itemsOf().length === 13 + skinCount,
+    check(itemsOf().length === 14 + skinCount,
       'the menu lists fixed actions and corners plus exactly one entry per skin',
-      `${itemsOf().length} items = 13 + ${skinCount} skin(s)`)
+      `${itemsOf().length} items = 14 + ${skinCount} skin(s)`)
     const byText = (t) => itemsOf().filter((i) => i.textContent.includes(t))
     const heads = menuOf().querySelectorAll('.wisp-menu-head')
     check(heads.length === 3, 'the behaviour, position and skin sections each get a header', `${heads.length} headers`)
@@ -2618,7 +2783,8 @@ if (clientSrc !== null) {
       const skins = Object.keys(value)
       const missing = []
       for (const skin of skins) {
-        for (const mood of ['idle', 'happy', 'sleepy', 'work', 'attn', 'poked']) {
+        /* 八个情绪：加了 eat（干饭）之后这里也要跟上 —— 漏一个就会让"每套皮肤都齐"变成假绿。 */
+        for (const mood of ['idle', 'happy', 'sleepy', 'work', 'attn', 'poked', 'proud', 'eat']) {
           const uri = value[skin]?.[mood]
           if (typeof uri !== 'string' || uri.indexOf('data:image/') !== 0) missing.push(`${skin}/${mood}`)
         }
@@ -2629,8 +2795,8 @@ if (clientSrc !== null) {
       skinReport = `table does not evaluate: ${error.message}`
     }
   }
-  if (skinsOk) ok('every skin carries all five moods as data URIs', skinReport)
-  else bad('every skin carries all five moods as data URIs', skinReport)
+  if (skinsOk) ok('every skin carries all eight moods as data URIs', skinReport)
+  else bad('every skin carries all eight moods as data URIs', skinReport)
 
   if (clientSrc.includes('__SPRITES__')) bad('no leftover build placeholder', 'run `node build.mjs`')
   else ok('no leftover build placeholder')