dsh-pet-live2d 2.0.2 → 2.2.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # 更新日志
 
+## 2.2.0
+
+### 多接三个会话状态（对着 DSH 0.1.7 的事件表挑的）
+
+0.1.7 里能订阅的事件有 100 个，但只有一部分能翻译成"宠物该演什么"。挑的标准是
+**它填的是不是一个真实的空档**：
+
+| 新相位 | 来自 | 以前的样子 |
+|---|---|---|
+| `asking` | `user-questions/request` | 它问你问题、等你回答的整段时间里，宠物还在演"干活" —— 最大的一个空档 |
+| `helper` | `subagent/start` / `subagent/end` | 子代理是**长活**（几分钟），和一次普通工具调用混在一起看不出区别 |
+| `queued` | `agent/inbox/inserted` | 你发的话在它忙的时候排队，宠物毫无反应 |
+
+`asking` 挂的是 waterfall：链一直挂到你答完才 resume，所以这个相位**正好**等于"卡在等你"
+的那一段，不用自己计时。`queued` 是短促反应（1.6 秒），回落到**排队前那个相位**而不是
+一律回 idle —— 否则一个正在跑工具的回合看起来像停了。
+
+**没接的**（评估过，理由写在 `lib/index.js` 的注释里）：`fs/write-intent` / `edit-intent`
+（tool 相位已经演「写本本」了，再拆一个 editing 和它重复）、`workflow/*`（工作流本身就是
+工具调用，已被 tool 覆盖）、`agent/status`（只有 idle / running 两个值，给不出更细的）。
+
+## 2.1.0
+
+### 会话相位改成真正的"接管"
+
+用户报的："我在爱心眼冒爱心掏出手机自拍的时候进入会话状态，右手会停在手机状态且一直冒爱心。"
+
+原来相位**只接管它点名的槽位**，其余槽位继续用你自己的选择 —— 于是那套"手机 + 爱心"
+在整场会话里一直挂着。现在相位一开始，宠物换相位那一套样子：
+
+- 相位点名的槽位用它抽到的；
+- 相位**没点名**的槽位**一律让位**（收回）；挂在槽位上的定格动作（掏出手机）也跟着
+  交还身体，手放下来 —— 手机停着不放是有两个原因叠在一起：槽位没让位，而且
+  "替别的槽位保姿势"那份名单相位走不到，一直每帧把手机姿势写回去；
+- **装扮槽永远归你**（眼镜 / 发饰 / 魔爪 / 巴菲 / 桌布 / 手机换色），相位不碰；
+- 会话进行中手点某个槽位会**临时盖过**相位的那一格（以前点了没反应，因为相位压着它）；
+- 会话结束后你原来的样子回来 —— 让位不是删除。
+
+### 右键面板的「装扮」跟着相位走
+
+用户报的："会话的状态没有在右键菜单的装扮里同步 button。"
+
+面板原来读的是**你自己的选择**，相位接管后画面上是相位的样子、面板还显示你上次手选的。
+现在两边读同一个"此刻显示什么"（`effectiveSlotChoice`）：相位点名用相位的，会话中没点名
+的整格空着，装扮槽永远显示你自己的。
+
 ## 2.0.2
 
 **只改文档**（宠物自带的那份 README，`pets/ds-whale-girl/README.md`）。它落后得比主 README

package/README.md

@@ -74,8 +74,24 @@ dsh plugin --profile web add "link:./dsh-pet-live2d/dsh-live2d-pet"
 
 ### 会话相位：同一套池子
 
-每个会话相位（`thinking` / `tool` / `waiting` / `done` / `failed`）下面是"槽位 → 条目表"，
-机制和摸鱼一样。相位表**一开始就列出全部相位**，显示的是**有效池子**：
+每个会话相位下面是"槽位 → 条目表"，机制和摸鱼一样。**宠物跟着 DSH 的真实事件换相位**：
+
+| 相位 | 什么时候 | 这只宠物演什么 |
+|---|---|---|
+| `thinking` | 模型在想 / 刚开工 | 抬头看 |
+| `tool` | 调工具（detail 带工具名） | 写本本 + 流汗 |
+| `waiting` | 有操作**等你批准** | 问号 |
+| `asking` | 它**问了你一个问题**、在等你回答 | 举手 + 问号 |
+| `helper` | 起了**子代理**（一段长活） | 喵喵手 + 调皮 |
+| `queued` | 你发的话**排队**了（它还在忙） | 感叹号（短促一下） |
+| `done` | 这一轮说完（庆祝 3.5 秒） | 开心 + 情绪花花 |
+| `failed` | 出错了 | 大哭 + 流汗 |
+
+来源是 `agent/status`、`tools/pre-execute|post-execute`、`approval/request`、
+`user-questions/request`、`subagent/start|end`、`agent/inbox/inserted`、
+`agent/turn-stopping`、`agent/error` —— 按主题折成上面这几个相位。
+
+相位表**一开始就列出全部相位**，显示的是**有效池子**：
 
 | 行头标记 | 含义 | 那一行有什么 |
 |---|---|---|
@@ -85,6 +101,17 @@ dsh plugin --profile web add "link:./dsh-pet-live2d/dsh-live2d-pet"
 改动**只在真的编辑时才落盘**，所以"看一眼"不会留下覆盖 —— 以后宠物更新了默认值，
 没改过的相位照样吃得到。
 
+**相位是"接管"，不是"叠加"**：会话一开始，宠物换相位那一套样子 ——
+
+- 相位**点名**的槽位用它抽到的（`thinking` 就是头顶鲸 + 画笔）；
+- 相位**没点名**的槽位**一律让位**（收回）：你手选的掏出手机、爱心眼、自拍不会在整场
+  会话里一直挂着。挂在槽位上的动作（掏出手机是定格动作）也会跟着交还身体，手放下来；
+- **装扮槽永远归你**：眼镜 / 发饰 / 魔爪 / 巴菲 / 桌布 / 手机换色 会话不碰；
+- 会话进行中想改也能改：手点一下会**临时盖过**相位的那一格（这场会话里有效）；
+- 会话**结束**后，你原来的样子回来（让位不是删除）。
+
+右键面板的「装扮」页签跟着相位走 —— 会话中它显示的是**相位抽到的**，不是你上次手选的。
+
 ### 关系：同时（pairs）与前提（requires）
 
 条目下面缩进那一层是**关系**，两种刻意用不同前缀：

package/lib/client.js

@@ -3248,7 +3248,18 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       // 相位池和摸鱼池是同一套抽签，所以诊断也照抄摸鱼的形状：`phaseNow` 立刻重抽
       // 一次（不用等真的相位切换），`phaseTally` 给出每个相位各抽中了什么。
       // 没有这两个的话，"池子里是随机的"就只能靠反复推 SSE 再数，慢且会抖。
-      api.phaseNow = (phase) => { if (typeof phase === "string") flushPhaseRef.current?.(phase); };
+      /**
+       * 诊断：直接应用一个相位（测试用）。
+       *
+       * **连状态一起设**，跟真实 SSE 路径一致：只调 applyPhase 的话 `data-phase` 还是
+       * 旧值、React 也不会重渲染 —— 面板跟着相位走这件事就测不出来（而且测出来的行为
+       * 跟真实路径不一样）。
+       */
+      api.phaseNow = (phase) => {
+        if (typeof phase !== "string") return;
+        setPhaseState(phase);
+        flushPhaseRef.current?.(phase);
+      };
       api.phaseTally = () => phaseTallyRef.current;
       api.resetPhaseTally = () => { phaseTallyRef.current = {}; };
       // 诊断：**有效关系**（pet.json + 用户覆盖合并后的结果）与存档里的覆盖。
@@ -3809,6 +3820,114 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       motion.current.playOnce(group, index, { kind: "panel" });
     }, []);
 
+    /**
+     * 一个槽位**此刻**显示的是什么 —— 面板高亮、配对、动作守卫三处都读它。
+     *
+     * 三段：
+     *   1. **装扮槽**永远归用户：眼镜/发饰/魔爪/巴菲/桌布/手机换色是"穿在身上的"，
+     *      会话相位不碰它们（用户明确要求），哪怕相位的池子里点了名；
+     *   2. 相位**点名**了这个槽位 → 用相位的选择（可能是 null = 相位说这里空着）；
+     *   3. 会话进行中、而相位没点名 → **空**：相位是"接管"，没点名的槽位也要让位。
+     *      以前这里退回用户的选择，于是"爱心眼 + 冒爱心 + 掏出手机"在整场会话里一直
+     *      挂着（用户报的"会话时没有把插槽重置"）；
+     *   4. 其余 → 用户自己的选择。
+     */
+    const effectiveSlotChoice = (slotId) => {
+      if (OUTFIT_SLOTS.indexOf(slotId) !== -1) return slotSelectionsRef.current[slotId];
+      if (Object.prototype.hasOwnProperty.call(phaseChoicesRef.current, slotId)) {
+        return phaseChoicesRef.current[slotId];
+      }
+      if (phaseRef.current !== "idle") return undefined;
+      return slotSelectionsRef.current[slotId];
+    };
+
+    /** 某个槽位此刻挂着哪个动作组（读**有效选择**）。 */
+    const motionGroupOfSlot = (slotId) => {
+      const label = effectiveSlotChoice(slotId);
+      if (label === undefined || label === null) return null;
+      const picked = (petRef.current?.expressionSlots ?? [])
+        .find((slot) => slot.id === slotId)?.options.find((o) => o.label === label);
+      return typeof picked?.motion === "string" ? picked.motion : null;
+    };
+
+    /**
+     * 身体此刻该播哪个动作 —— 按**有效选择**扫一遍槽位。
+     *
+     * "最后点的那个槽位"优先（`motionOwnerRef`），它不再是动作选项时回退到"扫描全部槽位
+     * 取第一个带 motion 的"。只用扫描会在"右手拿着手机时点吹泡泡糖"时把后者静默忽略
+     * （右手在清单里排在嘴部之前），只用记忆会在槽位被换掉后留下陈旧值。
+     */
+    const desiredSlotMotion = () => {
+      const owner = motionOwnerRef.current;
+      if (owner !== null) {
+        const owned = motionGroupOfSlot(owner);
+        if (owned !== null) return owned;
+      }
+      for (const other of petRef.current?.expressionSlots ?? []) {
+        const found = motionGroupOfSlot(other.id);
+        if (found !== null) return found;
+      }
+      return null;
+    };
+
+    /**
+     * 重算"替哪些*别的*槽位保姿势"。
+     *
+     * 身体只有一个动作，但姿势可以同时存在（掏出手机 + 吹泡泡糖，两组参数不相交），
+     * 所以除了当前演的那个，其余还挂着动作的槽位要把最后一帧写回去。
+     *
+     * **相位接管后也要重算**：那时候用户的槽位动作已经让位，姿势就不该再保着 —— 不然
+     * 会一直举着手机（用户报的"进入会话状态右手会停在手机状态"，根因就是这份名单只在
+     * `chooseSlotOption` 里更新，相位走不到）。
+     */
+    const syncKeptPoses = (playing) => {
+      const keepGroups = [];
+      for (const other of petRef.current?.expressionSlots ?? []) {
+        const found = motionGroupOfSlot(other.id);
+        if (found !== null && found !== playing && keepGroups.indexOf(found) === -1) keepGroups.push(found);
+      }
+      motion.current.setKeptPoses(keepGroups);
+    };
+
+    /**
+     * 把身体切到"有效选择要求的那一个动作"。
+     *
+     * **槽位点选和相位接管共用这一个**：相位接管时用户的槽位让位，挂在槽位上的
+     * `hold + persist` 动作（掏出手机/吹泡泡糖/自拍）必须跟着交还身体 —— 不然手会一直
+     * 举着手机（用户报的"进入会话状态右手会停在手机状态"）。相位接管以前不走这条，
+     * 于是那只手谁也放不下来。
+     */
+    const syncSlotMotion = () => {
+      const desired = desiredSlotMotion();
+      const previous = slotMotionRef.current;
+      slotMotionRef.current = desired;
+      // 只在"该播的动作真的换了"时才播 —— 原来还有个 `|| option !== null`，
+      // 意思是点任何表情都顺手把当前动作重播一遍。它会**重新快照**，而这时
+      // 动作早就在最后一帧停着了：掏出手机之后点爱心眼，快照里的 phone 记的就是
+      // 1（手机已在手里），于是"还原"忠实地把手机举着不放。
+      // 用户报的"掏出手机切不到其他状态"就是这个。
+      if (desired !== null && desired !== previous) {
+        motion.current.playOnce(desired, 0, { kind: "slot", hold: true, persist: true });
+      } else if (desired === null && previous !== null) {
+        // The slot gave up its motion: hand the body back. Other slots' pins
+        // are untouched, so their look survives.
+        motion.current.playIdle();
+      }
+    };
+
+    /**
+     * 会话进行中，手点（或配对带出）某个槽位时，**同时**改掉相位的这一格。
+     *
+     * 相位接管着这个槽位，只改用户的选择是看不见的 —— 用户会以为"点了没反应"。
+     * 覆盖只在这一场会话里有效：下一条相位消息来了就重新抽（`applyPhase` 从空开始）。
+     * 装扮槽不参与（它永远归用户，相位本来也压不过它）。
+     */
+    const markPhaseOverride = (slotId, label) => {
+      if (phaseRef.current === "idle") return;
+      if (OUTFIT_SLOTS.indexOf(slotId) !== -1) return;
+      phaseChoicesRef.current[slotId] = label === undefined ? null : label;
+    };
+
     /**
      * 「同时」(pairs) 的**不变量**：把当前选择里所有配对的目标表达式补进来。
      *
@@ -3819,14 +3938,12 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
      * 放在这里而不是 commitPins：**这是所有路径都经过的那个漏斗**（面板点选、摸鱼抽中、
      * 相位切换、归位、换宠物），只有一处的规则才不会走岔。
      *
-     * 源头取**有效选择**：相位正在接管某个槽位时以相位为准，否则相位演别的表情时
-     * 还会硬把配对目标钉在脸上（相位结束后自动回来）。
+     * 源头取**有效选择**（`effectiveSlotChoice`）：相位接管中以相位为准。
      */
     const pairPinsNow = () => {
       const pins = {};
       for (const slotId of slotByIdRef.current.keys()) {
-        const owns = Object.prototype.hasOwnProperty.call(phaseChoicesRef.current, slotId);
-        const label = owns ? phaseChoicesRef.current[slotId] : slotSelectionsRef.current[slotId];
+        const label = effectiveSlotChoice(slotId);
         if (label === null || label === undefined) continue;
         for (const [targetSlot, targetLabel] of Object.entries(relationsOf(slotId, label).pairs)) {
           const target = slotByIdRef.current.get(targetSlot)?.options.find((o) => o.label === targetLabel);
@@ -4038,6 +4155,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
           if (wanted) chosen[slotId] = label;
           else delete chosen[slotId];
           slotSelectionsRef.current = chosen;
+          markPhaseOverride(slotId, wanted ? label : null);
       saveOutfit();
           if (!wanted && typeof target.options.find((o) => o.label === label)?.motion === "string") {
             slotMotionRef.current = null;
@@ -4111,6 +4229,9 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       if (option === null) delete chosen[slot.id];
       else chosen[slot.id] = option.label;
       slotSelectionsRef.current = chosen;
+      // 会话进行中点的：相位正接管着这个槽位，只改用户选择是**看不见的** —— 同时把
+      // 相位的这一格也改掉（只在这一场会话里有效，下一条相位消息来了就重抽）。
+      markPhaseOverride(slot.id, option === null ? null : option.label);
       applyExpressions(next);
       // A motion attached to a slot plays and PARKS on its last frame, so the
       // chosen look stays put instead of dropping back to the idle loop.
@@ -4125,51 +4246,17 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       else userSweepRef.current = option.sweep;
       applySweep();
       // 身体只有一个动作。**最后点的那个槽位**优先（见 motionOwnerRef），它不再是动作
-      // 选项时回退到"扫描全部槽位取第一个带 motion 的" —— 后者是原来的唯一规则，也正是
-      // "右手拿着手机时点吹泡泡糖被静默忽略"的原因（右手在清单里排在嘴部之前）。
-      const motionOf = (slotId) => {
-        const label = slotSelectionsRef.current[slotId];
-        if (label === undefined) return null;
-        const picked = (petRef.current?.expressionSlots ?? [])
-          .find((slot) => slot.id === slotId)?.options.find((o) => o.label === label);
-        return typeof picked?.motion === "string" ? picked.motion : null;
-      };
+      // 选项时回退到扫描 —— 规则收在 `desiredSlotMotion()` 里，相位接管走的是同一个。
+      //
       // 先把归属改掉，再算 desired：否则"刚点的这个"要等下一次点击才生效。
       if (option !== null && typeof option.motion === "string") motionOwnerRef.current = slot.id;
       else if (motionOwnerRef.current === slot.id) motionOwnerRef.current = null;
-      let desired = motionOwnerRef.current === null ? null : motionOf(motionOwnerRef.current);
-      if (desired === null) {
-        for (const other of petRef.current?.expressionSlots ?? []) {
-          const found = motionOf(other.id);
-          if (found !== null) {
-            desired = found;
-            break;
-          }
-        }
-      }
+      const desired = desiredSlotMotion();
       // 身体只有一个动作，但**姿势可以同时存在**：别的槽位还选着动作时，替它们把最后
       // 一帧的姿势写回去（掏出手机 + 吹泡泡糖，两组参数不相交）。清掉那个槽位就等于把
       // 它从名单里去掉，它写过的手会交还出去。
-      const keepGroups = [];
-      for (const other of petRef.current?.expressionSlots ?? []) {
-        const found = motionOf(other.id);
-        if (found !== null && found !== desired && keepGroups.indexOf(found) === -1) keepGroups.push(found);
-      }
-      motion.current.setKeptPoses(keepGroups);
-      const previous = slotMotionRef.current;
-      slotMotionRef.current = desired;
-      // 只在"该播的动作真的换了"时才播 —— 原来还有个 `|| option !== null`，
-      // 意思是点任何表情都顺手把当前动作重播一遍。它会**重新快照**，而这时
-      // 动作早就在最后一帧停着了：掏出手机之后点爱心眼，快照里的 phone 记的就是
-      // 1（手机已在手里），于是"还原"忠实地把手机举着不放。
-      // 用户报的"掏出手机切不到其他状态"就是这个。
-      if (desired !== null && desired !== previous) {
-        motion.current.playOnce(desired, 0, { kind: "slot", hold: true, persist: true });
-      } else if (desired === null && previous !== null) {
-        // The slot gave up its motion: hand the body back. Other slots' pins
-        // are untouched, so their look survives.
-        motion.current.playIdle();
-      }
+      syncKeptPoses(desired);
+      syncSlotMotion();
       // A dress-up choice PERSISTS. The auto-clear exists so a reaction or a
       // session phase cannot leave the pet stuck, but an outfit is an explicit
       // choice the user reverses from this panel (or with 归位), and expiring it
@@ -4256,6 +4343,10 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
        * 三轮不动就收手。
        */
       const applyPhase = (phase) => {
+        // 相位名记在这里（而不是只记在 SSE 回调里）：`effectiveSlotChoice` 靠它判断
+        // "会话进行中"，而诊断读口 `phaseNow()` 是直接调这个函数的 —— 分开写的话，
+        // 诊断走的相位不会让槽位让位，测出来的行为跟真实路径不一样。
+        phaseRef.current = phase;
         const slotById = new Map((pet?.expressionSlots ?? []).map((slot) => [slot.id, slot]));
         const pools = phasePoolsFor(phase);
         // 从**空**开始，而不是继承上一个相位的答案：相位是接管，不是叠加。
@@ -4367,6 +4458,9 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         }
         phaseGroupRef.current[phase] = group;
         phasePoolsRev.current = JSON.stringify(pools);
+        // 相位接管后重算"替谁保姿势"：用户那套槽位动作已经让位，姿势就不该再保着，
+        // 否则手会一直举着手机。名单过去只在 chooseSlotOption 里更新，相位走不到。
+        syncKeptPoses(group);
         const sustained = PHASE_SUSTAIN.indexOf(phase) !== -1;
         if (phase === "idle" || group === undefined) {
           // No motion for this phase: stop sustaining and return to rest.
@@ -4395,13 +4489,8 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       // selections, so it stays true while the look keeps the phone out and goes
       // false the moment the slot changes.
       motion.current.setGuardResolver((group) => {
-        // 相位"抽空了"这个槽位时不能退回用户的选择：owns 为真且值是 null 就是空。
-        const chosenOf = (slotId) => {
-          const owns = Object.prototype.hasOwnProperty.call(phaseChoicesRef.current, slotId);
-          return owns ? phaseChoicesRef.current[slotId] : slotSelectionsRef.current[slotId];
-        };
         const holds = (slotId, labels) => {
-          const chosen = chosenOf(slotId);
+          const chosen = effectiveSlotChoice(slotId);
           return chosen !== undefined && chosen !== null && labels.includes(chosen);
         };
         const guard = guardsRef.current[group];
@@ -4937,7 +5026,11 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
                 // "every expression is pinned": a motion-only option has an EMPTY
                 // expression list, and [].every(...) is vacuously true, so
                 // 掏出手机 and 吹泡泡糖 rendered as permanently pressed.
-                const chosenLabel = slotSelectionsRef.current[slot.id];
+                //
+                // 读的是**有效选择**（`effectiveSlotChoice`）：会话相位接管时，面板要跟着
+                // 显示相位抽到什么，而不是你上一次手选的 —— 以前两边脱节，用户报过
+                // "会话的状态没有在右键菜单的装扮里同步 button"。
+                const chosenLabel = effectiveSlotChoice(slot.id);
                 const active = slot.options.find((option) => option.label === chosenLabel);
                 return h("div", { "data-group": "", key: slot.id, "data-slot": slot.id },
                   h("span", null, slot.label),

package/lib/index.js

@@ -803,11 +803,16 @@ function runtimeRoute() {
 // comment frame.
 
 /** The activity phases the browser half understands. */
-export const ACTIVITY_PHASES = ['idle', 'thinking', 'waiting', 'tool', 'done', 'failed']
+export const ACTIVITY_PHASES = [
+  'idle', 'thinking', 'waiting', 'asking', 'tool', 'helper', 'queued', 'done', 'failed',
+]
 
 /** How long the 'done' celebration is held before falling back to idle. */
 const DONE_HOLD_MS = 3500
 
+/** "你的消息排队了"给一个短促的收到反应，然后回到原来在演的东西。 */
+const QUEUED_HOLD_MS = 1600
+
 /** SSE keep-alive interval. */
 const SSE_PING_MS = 30000
 
@@ -820,7 +825,7 @@ export class ActivityHub {
     this.phase = 'idle'
     this.detail = ''
     this.listeners = new Set()
-    this.doneTimer = undefined
+    this.holdTimer = undefined
   }
 
   /** Current snapshot (sent as the first frame of every stream). */
@@ -841,19 +846,30 @@ export class ActivityHub {
     this.emit()
   }
 
+  /**
+   * 演一个**短促反应**相位，过一会儿自动回落到 `fallback`。
+   *
+   * `done`（庆祝）和 `queued`（收到你排队的消息）都是这一类：宠物演一下，然后回到
+   * 它该在的地方。回落之前会确认相位没被别人接管 —— 这段时间里工具开始了、或者
+   * 新一轮说话了，就不要再把它拽回旧的 fallback。
+   */
+  hold(phase, ms, fallback = 'idle') {
+    if (this.holdTimer !== undefined) clearTimeout(this.holdTimer)
+    this.set(phase, '')
+    this.holdTimer = setTimeout(() => {
+      this.holdTimer = undefined
+      if (this.phase === phase) this.set(fallback, '')
+    }, ms)
+    // Keep the process free to exit; the timer is purely cosmetic.
+    this.holdTimer?.unref?.()
+  }
+
   /**
    * Enter the 'done' celebration and fall back to idle after a hold, so the
    * pet visibly finishes a turn instead of snapping straight back.
    */
   celebrate() {
-    if (this.doneTimer !== undefined) clearTimeout(this.doneTimer)
-    this.set('done', '')
-    this.doneTimer = setTimeout(() => {
-      this.doneTimer = undefined
-      this.set('idle', '')
-    }, DONE_HOLD_MS)
-    // Keep the process free to exit; the timer is purely cosmetic.
-    this.doneTimer?.unref?.()
+    this.hold('done', DONE_HOLD_MS, 'idle')
   }
 
   emit() {
@@ -868,9 +884,9 @@ export class ActivityHub {
   }
 
   dispose() {
-    if (this.doneTimer !== undefined) {
-      clearTimeout(this.doneTimer)
-      this.doneTimer = undefined
+    if (this.holdTimer !== undefined) {
+      clearTimeout(this.holdTimer)
+      this.holdTimer = undefined
     }
     this.listeners.clear()
   }
@@ -958,6 +974,53 @@ export function attachActivityEvents(ctx, hub) {
     }, TOOL_IDLE_MS)
     return next()
   })
+
+  // ---- DSH 0.1.7 里另外三个值得接的状态 --------------------------------------
+  //
+  // 事件词汇表在 0.1.7 里已经不小（`*.d.ts` 里声明了 100 个可订阅事件），但只有一部分
+  // 能翻译成"宠物该演什么"。挑的标准是**它填的是不是一个真实的空档**：
+  //
+  //   asking  ← user-questions/request：以前"在等你回答问题"这段时间宠物还在演"干活"，
+  //             看着像它没停过 ✗ —— 这是最大的一个空档；
+  //   helper  ← subagent/start|end：子代理是**长活**（几分钟），和一次普通工具调用
+  //             混在一起看不出区别；
+  //   queued  ← agent/inbox/inserted：你发的话在它忙的时候插进来，现在至少给个"收到"。
+  //
+  // 没接的（评估过，不值得）：`fs/write-intent` / `edit-intent` —— 宠物在 tool 相位已经
+  // 演「写本本」了，再拆一个 editing 和它重复；`workflow/*` —— 工作流本身是工具调用，
+  // 已被 tool 覆盖（`workflow/phase` 的标题倒是可以当 detail，但宠物目前不显示 detail）；
+  // `agent/status` 只有 idle / running 两个值，给不出更细的东西。
+
+  // `user-questions/request` 是 waterfall：链一直挂到**你把问题答完**才 resume，所以
+  // 这个相位正好等于"卡在等你"的那段，不用自己计时。
+  onWaterfall('user-questions/request', (_request, next) => {
+    hub.set('asking', '')
+    const answered = typeof next === 'function' ? next() : undefined
+    const back = () => {
+      if (hub.phase === 'asking') hub.set('thinking', '')
+    }
+    if (answered !== null && typeof answered?.then === 'function') {
+      answered.then(back, back)
+      return answered
+    }
+    back()
+    return answered
+  })
+  on('subagent/start', (info) => {
+    const label = typeof info?.name === 'string'
+      ? info.name
+      : (typeof info?.label === 'string' ? info.label : '')
+    hub.set('helper', label)
+  })
+  on('subagent/end', () => {
+    if (hub.phase === 'helper') hub.set('thinking', '')
+  })
+  on('agent/inbox/inserted', () => {
+    // 回到"刚才在演的那个"（可能是 tool / asking，也可能是 idle）——不要一律回 idle，
+    // 那会让一个正在跑工具的回合看起来停了。
+    const previous = hub.phase
+    hub.hold('queued', QUEUED_HOLD_MS, previous === 'queued' ? 'thinking' : previous)
+  })
 }
 
 /** The activity stream + snapshot route. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-pet-live2d",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "description": "Live2D 桌宠插件：为 DSH Web GUI 挂一只可拖动、会跟随鼠标、能换动作与表情的 Live2D 宠物。",
   "type": "module",
   "main": "lib/index.js",

package/pets/ds-whale-girl/pet.json

@@ -568,6 +568,22 @@
         "lhand": "橡皮",
         "symbol": "问号"
       },
+      "asking": {
+        "whale": "头顶鲸",
+        "rhand": "双手比耶",
+        "mood": "开心兴奋",
+        "symbol": "问号"
+      },
+      "helper": {
+        "whale": "头顶鲸",
+        "rhand": "喵喵手",
+        "mood": "调皮"
+      },
+      "queued": {
+        "whale": "头顶鲸",
+        "mood": "开心兴奋",
+        "symbol": "感叹号"
+      },
       "done": {
         "whale": "头顶鲸",
         "lhand": "橡皮",