dsh-galatea 0.4.3 → 0.4.5

package/README.md

@@ -13,7 +13,7 @@
 | 块 | 状态 |
 |---|---|
 | 能被 DSH 装起来 | ✅ 实测通过（dsh 0.2.2-rc.3） |
-| 发布到 npm | ✅ 0.3.8（GitHub Actions 自动发，不需要 token） |
+| 发布到 npm | ✅ 0.4.5（GitHub Actions 自动发，不需要 token） |
 | 记忆：读写 Markdown | ✅ 15 条测试 |
 | 记忆：注入索引 | ✅ **已核实内容真的进了上下文**（不是在会话日志里看到「接上了没告警」） |
 | 记忆：`remember` / `recall` | ✅ 23 条测试 |
@@ -27,10 +27,14 @@
 | 心跳：沉默可解释 | ✅ `galatea_beat` 会把最近几次的决定翻成人话 |
 | 心跳：听得见你说话 | ⚠️ 接了 `agent/pre-step`，**但那条事件有没有真的触发，没验过** |
 | 设置页可改的字段 | ⚠️ 声明被宿主接受，**表单没在 GUI 里看过** |
-| 心跳：定时器 + 自动开口 | ⬜ 未做 |
+| 心跳：定时器自己跑 | ✅ 实测：每 60 秒一次，账本持续累积，跨进程存活 |
+| 心跳：改配置立刻生效 | ✅ 定时器只负责「醒」，跑不跑每次现读配置 |
+| 心跳：自动开口（真的送出去） | ⬜ 未做 —— **这一版只算不发，但算得对了** |
 
-> ⚠️ **它现在还不会自己开口。** 定时器和 `ctx.agents.resume` 都还没接，
-> 判定链路完整，但没有出口。别把「测试全绿」读成「它已经在主动找你了」。
+> ⚠️ **它现在还不会自己开口。** 定时器接上了，判定链路也完整了
+> （会算出「该不该说、对谁说、拿哪条当由头」），
+> 但把话真的送出去那一步还没接。
+> 别把「账本在长」读成「它已经在主动找你了」。
 
 关于上面那条 ⚠️：`noteUserMessage` 接在 `agent/pre-step` 上，用来记「你刚说过话」
 （cooldown 要用它）。**本机验证只到「加载不崩」**——那个测试 profile 里没有会话，
@@ -60,7 +64,7 @@
 
 ## 设置（不用改代码）
 
-六个字段声明为 `.volatile()`，所以 DSH 的设置页会照着 schema 自动生成表单，
+七个字段声明为 `.volatile()`，所以 DSH 的设置页会照着 schema 自动生成表单，
 改完**不重启插件**：
 
 | 字段 | 说明 |
@@ -70,9 +74,14 @@
 | `minGapMinutes` | 两次心跳最少隔多久 |
 | `dice` | 没有由头时的开口概率。0 = 只在有素材时说 |
 | `quietRounds` | 连续多少轮没开口就强制说一次。0 = 关掉这个保底 |
+| `autoBeatMinutes` | 每隔多少分钟自己跑一次。0 = 关（默认）。**改完立刻生效，不用重启** |
 
-三处容易踩的：
+四注意：
 
+- **`autoBeatMinutes` 小于 `minGapMinutes` 时，实际频率由后者决定。** 比如设 1 分钟、
+  最小间隔 20 分钟，就是每 20 分钟才真正判定一次，中间那些跳只记一条 `tooSoon`。
+  这不是没生效，是间隔在压着它 —— 装的时候会把这句话写进 marker 文件。
+  定时器本身固定 60 秒醒一次，跑不跑由这个数现读现定。
 - **「连续几轮没开口就强制一次」和「最少间隔」是耦合的。** 心跳间隔设得比保底所需的时间还短，保底永远不会触发。
 - **把 `quietRounds` 关掉，它可能安静到让你以为坏了。** 默认闭嘴需要一条下限，不然沉默和故障长得一样。
 - **安静时段优先于保底，但保底不会被清零。** 两者撞上时，安静时段赢：那段时间它不说话。可是「连续没开口」的次数照常往上加，所以走出安静时段后的第一次心跳就会走保底 —— 保底只是被推迟，没有被悄悄关掉。
@@ -118,6 +127,66 @@
 
 门控可以自动决定，**内容不能自动生成**。空话比不说更糟，它消耗的是「它真的在」那点信用。
 
+## 一次教训：心跳把自己的基准刷掉了
+
+0.4.1 的定时器确实在跑，账本也确实在长，但里面永远是同一句：
+
+```
+16:36:15  tooSoon — 距上一轮心跳 1.0 分钟，不到 20
+16:37:15  tooSoon — 距上一轮心跳 1.0 分钟，不到 20
+16:38:15  tooSoon — 距上一轮心跳 1.0 分钟，不到 20
+```
+
+一个字段干了两件事：`lastBeatAt` 既是「上次跑过」，又是「上次判定的基准」。
+于是每一跳都把它刷成「现在」⟹ 下一跳读到的间隔永远等于定时器间隔
+⟹ 只要间隔小于 `minGapMinutes`，就永远 `tooSoon`，永远说不了第一句话。
+
+**它看起来完全正常**：进程活着、定时器在响、账本在长。
+唯一不对的，是它永远不会开口。
+
+现在拆成两个：
+
+| 字段 | 谁写 | 干什么 |
+|---|---|---|
+| `lastTickAt` | 每一跳都写 | 只回答「定时器还活着吗」 |
+| `lastBeatAt` | 只有**真的走到判定**的那一跳才写 | `minGapMinutes` 的基准 |
+
+判据不在调用方，在 `decide()` 自己返回的 `touchBeat` 里 ——
+两处各写一份必然漂移，而漂移的方向永远是「改了一处忘了另一处」。
+
+**「被挡住」不算一次心跳。** 安静时段、刚聊过、间隔不够，都只是时钟走了一格，
+不是一次「说不说」的机会。所以它们也不该让 `quietStreak` 往上加 ——
+否则 1 分钟一跳的定时器会在 20 分钟内把计数顶到 20，
+第一次真正判定就撞上下限保护，变成「每 20 分钟强制说一句」。
+一个 bug 修完，第二个 bug 就躲在同一个地方。
+
+这一条不是读代码读出来的。外面的人真机跑了七分钟，看到七条一模一样的
+`tooSoon`，才把它揪出来 —— **单元测试全绿，因为测试都是按「一分钟一跳不合法」
+去构造的**，而没有人试过「一小时里每一分钟都跳一次」。
+
+## 又一次教训：第七个字段是快照
+
+0.4.4 修完基准刷新，同样的形状又冒出来一次，方向正好相反：
+
+`autoBeatMinutes` 是 volatile 字段 —— 用户改它时插件**不会重新 mount**，
+这正是 volatile 的意义。可定时器的周期是在 `apply()` 里读一次就钉死的。
+于是在设置页把 5 改成 30，间隔永远停在 5，**而且没有任何地方会报错**。
+
+同一个文件里，六个字段走 `liveConfig(raw)` 每次现读，第七个成了启动时的快照。
+
+0.4.0 是「忘了读这个字段」，这次是「在错的时机读了它」。
+两次的表现一模一样：配了完全没反应，而两次的代码看起来都是对的。
+
+现在定时器跟配置解耦：
+
+| | 谁负责 |
+|---|---|
+| 定时器周期 | 固定 60 秒，只负责「醒」 |
+| 跑不跑、隔多久 | 每次醒的时候现读 `autoBeatMinutes`，用 `isDue(上次跑的时刻, 现在, 配置)` 判 |
+
+关着（0）也照常装定时器 —— 否则用户从 0 改成 5 的时候没人去装，又回到同一个坑。
+代价是每分钟空醒一次，读一个数字比大小。
+
 ## 一次教训：模块边界
 
 0.3.0 / 0.3.5 / 0.3.6 连着三次，坏的地方都在**两个文件交接处**：
@@ -147,13 +216,14 @@ $DSH_HOME/galatea/heartbeat-state.json                      # 心跳状态账本
 
 文件名就是 id。日期在前，所以目录列表天然按时间排。正文第一行是标题。
 
-状态账本记的是：上一轮什么时候跳的、上次开口是什么时候、连续几轮没说话、最近的决定。
+状态账本记的是：上一次**真正判定**是什么时候（`lastBeatAt`）、定时器上一次跑是什么时候
+（`lastTickAt`）、上次开口是什么时候、连续几轮**判定**没说话、最近的决定。
 它必须落盘——不落盘的话进程一重启计数就归零，下限保护立刻失效。
 
 ## 本地开发
 
 ```bash
-npm test          # 92 条，不依赖 DSH，纯 node
+npm test          # 101 条，不依赖 DSH，纯 node
 ```
 
 装了之后验证它真的加载了，只看一个东西：
@@ -174,7 +244,7 @@ dsh plugin add dsh-galatea
 或者在 profile 的 `package.json` 里手写：
 
 ```json
-"dependencies": { "dsh-galatea": "0.3.8" }
+"dependencies": { "dsh-galatea": "0.4.5" }
 ```
 
 **版本号钉死，不要写 `^`。** 同一个版本号指向两个不同的包，以后就说不清你装的是哪一份。

package/index.js

@@ -16,7 +16,8 @@ import z from '@deepseek-ai/schemastery';
 import { renderIndex, dataRoot, listEntries } from './lib/store.js';
 import { remember, recall } from './lib/tools.js';
 import { makeBeatTool, snapshotAgents } from './lib/beat-tool.js';
-import { loadState, noteUserMessage, stateFile, tick } from './lib/heartbeat-runner.js';
+import { commitDecision, isDue, loadState, noteUserMessage, saveState, stateFile } from './lib/heartbeat-runner.js';
+import { planBeat } from './lib/beat.js';
 import { DEFAULTS } from './lib/heartbeat.js';
 
 /** Cordis 插件名。 */
@@ -238,31 +239,89 @@ export function apply(ctx, config) {
   // 想确认它在动，看心跳账本里有没有新记录就够了。
   //
   // 默认关（autoBeatMinutes = 0）：一个会自己转的东西，不该在装上的那一刻就开始转。
-  const everyMin = Number(cfg.autoBeatMinutes ?? 0);
-  if (Number.isFinite(everyMin) && everyMin > 0) {
-    if (ctx && typeof ctx.interval === 'function') {
-      const ms = Math.max(60_000, everyMin * 60_000);
+  //
+  // ⚠ 间隔不能写进 ctx.interval 的周期里。
+  //   autoBeatMinutes 是 volatile 字段 —— 用户改它时插件**不会重新 mount**
+  //   （这正是 volatile 的意义：不重启）。而定时器是装一次就钉死的。
+  //   所以「每 N 分钟」一旦写进周期，改完设置页间隔永远不会变，
+  //   而且没有任何地方会报错 —— 同一个文件里六个字段是活的，第七个成了快照。
+  //   （0.4.0 是「忘了读这个字段」，这次是「在错的时机读了它」。）
+  //
+  //   改成固定一分钟醒一次，每次醒的时候**现读**配置，到点才真的跑。
+  //   代价是每分钟空醒一次（读一个数字比大小），换来的是改完立刻生效。
+  const TICK_MS = 60_000;
+  if (ctx && typeof ctx.interval === 'function') {
+    let lastRunAt = 0;
       // 用 ctx.interval，不用已 deprecated 的 ctx.setInterval —— 它返回 dispose，
       // 由当前 fiber 管着，宿主热重载时不会叠出第二个定时器。
       ctx.interval(() => {
         try {
-          tick({});
+          // 现读 —— volatile 字段唯一的正确用法。
+          // 取不到（没配过）就回落到 0，也就是「关着」。
+          const everyMin = Number(
+            raw && raw.autoBeatMinutes && typeof raw.autoBeatMinutes.get === 'function'
+              ? raw.autoBeatMinutes.get()
+              : cfg.autoBeatMinutes,
+          );
+          const nowMs = Date.now();
+          // 到点才真的跑。这一句是「改配置立刻生效」的全部秘密：
+          // 定时器只负责醒，什么时候真的跑由这个现读的数决定。
+          if (!isDue(lastRunAt, nowMs, everyMin)) return;
+          lastRunAt = nowMs;
+
+          const at = new Date(nowMs);
+          const state = loadState(stateFile());
+          // 走和手动档**同一条**链路（planBeat）。
+          //
+          // 上一版这里是 `tick({})`，它直接调门控、只带一个 state：
+          // 没有候选会话、没有素材、hasHardMaterial 永远 false。
+          // 于是自动档只能掷色子，手动档永远走硬素材 —— 两条路都叫心跳，
+          // 行为却正好相反，而两边各自的账本都「看起来在动」。
+          //
+          // 复用 planBeat 的代价是要拿 agents 和 entries，好处是：
+          // 自动档终于能算出「本来想说什么、打算对谁说」，而且
+          // 以后改目标选择/素材选择时，只需要改一处。
+          const r = planBeat({
+            now: at,
+            state,
+            candidates: snapshotAgents(ctx.agents),
+            entries: listEntries(),
+            config: liveConfig(raw),
+          });
+          saveState(commitDecision(state, r, at), stateFile());
         } catch (err) {
           // 定时器抛出去会打断整个宿主，所以在这里兜住，但要说出来
           console.warn('[galatea] 自动心跳失败:', err && err.message);
         }
-      }, ms);
-      console.log(`[galatea] 自动心跳已开：每 ${everyMin} 分钟跑一次（只算不发）`);
-    } else {
-      // 用户明确要求了、却被静默拒绝 —— 这一次不能只在 console 里说。
-      // 真机上 console.warn 用户看不见，表现是「配了完全不生效，也没有任何提示」。
-      const line = '[galatea] 你配了 autoBeatMinutes，但宿主没有 ctx.interval —— 自动心跳不会跑。';
-      console.warn(line);
+      }, TICK_MS);
+      console.log('[galatea] 自动心跳的钟已装：每 60 秒醒一次，按设置里的 autoBeatMinutes 决定跑不跑（0 = 不跑）');
+
+    // 一个很自然但会误会的组合：自动心跳间隔 < 最小间隔。
+    // 它**不是错误** —— minGap 会把节奏压回每 minGap 分钟一次。
+    // 但用户以为自己设的是 autoBeatMinutes，所以得把实际生效的那个数说出来。
+    const gapMin = Number(cfg.minGapMinutes ?? DEFAULTS.minGapMinutes);
+    const bootEvery = Number(cfg.autoBeatMinutes ?? 0);
+    if (
+      Number.isFinite(bootEvery) && bootEvery > 0 &&
+      Number.isFinite(gapMin) && gapMin > 0 && bootEvery < gapMin
+    ) {
+      const note = `[galatea] 自动心跳设的是每 ${bootEvery} 分钟一次，但最小间隔是 ${gapMin} 分钟 —— 实际每 ${gapMin} 分钟才真正判定一次（不是没生效，是被间隔压住了）。`;
+      console.warn(note);
       try {
-        appendFileSync(marker, `  ${line}\n`);
+        appendFileSync(marker, `  ${note}\n`);
       } catch {
         // 记录失败不该连累插件
       }
     }
+  } else if (Number(cfg.autoBeatMinutes ?? 0) > 0) {
+    // 用户明确要求了、却被静默拒绝 —— 这一次不能只在 console 里说。
+    // 真机上 console.warn 用户看不见，表现是「配了完全不生效，也没有任何提示」。
+    const line = '[galatea] 你配了 autoBeatMinutes，但宿主没有 ctx.interval —— 自动心跳不会跑。';
+    console.warn(line);
+    try {
+      appendFileSync(marker, `  ${line}\n`);
+    } catch {
+      // 记录失败不该连累插件
+    }
   }
 }

package/lib/beat.js

@@ -56,14 +56,24 @@ export function planBeat(input) {
   }
 
   // ── ③ 现在该不该说 ──────────────────────────────────────
-  // hasHardMaterial = true：有具体的东西要说，就不掷色子。
-  // 色子留给「有点想法但没到非说不可」，这里不是那种情况。
+  //
+  // `hasHardMaterial` 这一版**没有判据**，所以默认 false。
+  //
+  // 原来这里是写死的 true，于是手动档和自动档各走一个极端：
+  //   手动档（走 planBeat）—— 只要有素材就必定开口，色子永远掷不到；
+  //   自动档（走 tick）    —— 永远 false，永远只掷色子，看不见素材。
+  // 两条路都自称「心跳」，行为却正好相反。
+  //
+  // 「有素材」只代表有东西可说，不代表现在非说不可 —— 把两件事合成一件，
+  // 结果是每有一条没读过的记忆就要说一次，比闹钟还吵。
+  //
+  // 将来接上真正硬的东西（承诺到期、上次没说完的），由调用方传 true。
   const decision = decide({
     now,
     lastBeatAt: state.lastBeatAt ?? null,
     lastUserAt: state.lastUserAt ?? null,
     lastSpokeAt: state.lastSpokeAt ?? null,
-    hasHardMaterial: true,
+    hasHardMaterial: input.hasHardMaterial === true,
     quietStreak: state.quietStreak ?? 0,
     config: cfg,
     random: input.random,
@@ -78,6 +88,7 @@ export function planBeat(input) {
     previous: target.previous,
     materialId: material.entry.id,
     detail: decision.detail,
+    touchBeat: decision.touchBeat,
   };
 
   function no(reason, detail, extra) {
@@ -90,6 +101,9 @@ export function planBeat(input) {
       previous: extra.previous,
       materialId: null,
       detail,
+      // 没走到 decide 的，都不算一次心跳 —— 那是「没人可说话 / 没得说」，
+      // 不是「判过了，结论是不说」。这两种要分开，否则 lastBeatAt 会被空转刷掉。
+      touchBeat: false,
     };
   }
 }

package/lib/heartbeat-runner.js

@@ -19,7 +19,16 @@ export function stateFile() {
 }
 
 export const EMPTY_STATE = {
+  /**
+   * 上一次**真正走到判定**的时刻。minGap 用的就是它。
+   *
+   * 它和 lastTickAt 是两个东西，混成一个会出死锁：
+   * 定时器每跳一次都刷新它 ⟹ 每次读到的 gap 都等于定时器间隔
+   * ⟹ 只要间隔小于 minGapMinutes，就永远 tooSoon，永远说不了话。
+   */
   lastBeatAt: null,
+  /** 上一次**定时器跑过**的时刻。每次跳都写，诊断用 —— 它不参与任何判据。 */
+  lastTickAt: null,
   lastSpokeAt: null,
   lastUserAt: null,
   quietStreak: 0,
@@ -68,14 +77,58 @@ export function commitDecision(state, decision, now = new Date(), opts = {}) {
   };
   const next = {
     ...state,
-    lastBeatAt: at,
-    quietStreak: decision.speak ? 0 : (state.quietStreak ?? 0) + 1,
+    lastTickAt: at,
     decisions: [...(state.decisions ?? []), entry].slice(-(opts.keepDecisions ?? 50)),
   };
+  // 「被 minGap / 安静时段 / 冷却挡住」的那一跳，只是时钟走了一格，
+  // 不说明有过一次「说不说」的机会 —— 所以下面两样都不该动，理由各一条：
+  //
+  //   ① lastBeatAt：动了它，minGap 的基准就被自己刷新，于是永远 tooSoon。
+  //   ② quietStreak：动了它，1 分钟一跳的定时器 20 分钟就能把计数顶到 20，
+  //      于是**第一次**真正判定就撞上下限保护 —— 用户以为设的是「偶尔说句」，
+  //      实际得到的是「每 20 分钟强制说一句」。
+  //
+  // 判据由 decide() 自己给（touchBeat），这里不猜 reason ——
+  // 两处各写一份必然漂移，而漂移的方向永远是「改了一处忘了另一处」。
+  //
+  // 默认 true：老调用点（不带这个字段的）行为不变，不会因为升级而卡住。
+  if (decision.touchBeat !== false) {
+    next.lastBeatAt = at;
+    next.quietStreak = decision.speak ? 0 : (state.quietStreak ?? 0) + 1;
+  }
   if (decision.speak) next.lastSpokeAt = at;
   return next;
 }
 
+/**
+ * 自动心跳的节流：这一跳**该不该真的跑一次**。
+ *
+ * 为什么单独一个函数，而不是直接把间隔写进定时器周期：
+ *
+ *   `autoBeatMinutes` 是 volatile 字段 —— 用户改它时插件**不会重新 mount**
+ *   （这正是 volatile 的意义：不重启）。而定时器的周期是装配那一刻钉死的。
+ *
+ *   所以「每 N 分钟」一旦写进 interval 的周期，用户改完设置页，
+ *   间隔永远不会变，而且**没有任何地方会报错** ——
+ *   同一个文件里六个字段是活的，第七个成了快照，看起来完全正常。
+ *   （0.4.0 是「忘了读这个字段」，这次是「在错的时机读了它」。）
+ *
+ *   拆开之后：定时器固定一分钟醒一次，醒的时候现读配置、用这个函数判。
+ *
+ * @param {number} lastRunAtMs  上次真的跑过的时刻（毫秒；<=0 表示从没跑过）
+ * @param {number} nowMs        现在（毫秒）
+ * @param {number} everyMinutes 配置里的间隔。<=0 或不是数字 ⟹ 关着，永不跑
+ * @returns {boolean}
+ */
+export function isDue(lastRunAtMs, nowMs, everyMinutes) {
+  const every = Number(everyMinutes);
+  if (!Number.isFinite(every) || every <= 0) return false;
+  const last = Number(lastRunAtMs);
+  // 从没跑过 ⟹ 立刻就绪。这样重启之后不会平白多等一个完整周期。
+  if (!Number.isFinite(last) || last <= 0) return true;
+  return Number(nowMs) - last >= every * 60_000;
+}
+
 export function tick(opts = {}) {
   const now = opts.now instanceof Date ? opts.now : new Date(opts.now ?? Date.now());
   const file = opts.file ?? stateFile();

package/lib/heartbeat.js

@@ -99,7 +99,21 @@ export function inQuiet(minuteOfDay, quiet) {
  * @param {object}  [input.config]         覆盖 DEFAULTS
  * @param {() => number} [input.random]    注入随机源，测试用
  *
- * @returns {{ speak: boolean, reason: string, detail: string }}
+ * @returns {{ speak: boolean, reason: string, detail: string, touchBeat: boolean }}
+ *
+ * `touchBeat` 是这个函数对调用方的第二条输出，和 speak 一样重要：
+ * 它回答「这一轮算不算一次心跳」。
+ *
+ * 被 quiet / tooSoon / cooldown 挡下的**不算** —— 那三种都是还没轮到判定，
+ * 只是定时器空跑了一次。如果把它们也记成心跳，minGap 的基准会被自己刷新：
+ *
+ *    定时器每 1 分钟一跳 → 每次读到的 gap 都是 1 → 永远小于 minGap(20)
+ *    → 永远 tooSoon → 永远走不到后面的分支
+ *
+ * 这个死锁长得很正常：账本里一直有新记录，定时器确实在动，
+ * 唯一不对的地方是**它永远不会说出第一句话**。外面的人真机跑了一轮才看出来。
+ *
+ * tooSoon 尤其不能算：它就是「距上次判定不够久」这件事本身。
  */
 export function decide(input) {
   const cfg = { ...DEFAULTS, ...(input.config ?? {}) };
@@ -108,7 +122,7 @@ export function decide(input) {
 
   // ── ① 安静时段：硬墙，先挡 ──────────────────────────────
   if (inQuiet(minutesOfDay(now), cfg.quiet)) {
-    return { speak: false, reason: 'quiet', detail: '落在用户设的安静时段里' };
+    return { speak: false, reason: 'quiet', detail: '落在用户设的安静时段里', touchBeat: false };
   }
 
   // ── ② 间隔：定时器抽风或上一轮太近，别叠 ────────────────
@@ -119,7 +133,8 @@ export function decide(input) {
       return {
         speak: false,
         reason: 'tooSoon',
-        detail: `距上一轮心跳 ${gap.toFixed(1)} 分钟，不到 ${cfg.minGapMinutes}`,
+        detail: `距上一次真正判定 ${gap.toFixed(1)} 分钟，不到 ${cfg.minGapMinutes}`,
+        touchBeat: false,
       };
     }
   }
@@ -133,6 +148,7 @@ export function decide(input) {
         speak: false,
         reason: 'cooldown',
         detail: `距用户上一条消息 ${since.toFixed(1)} 分钟，不到 ${cfg.cooldownMinutes}`,
+        touchBeat: false,
       };
     }
   }
@@ -148,10 +164,11 @@ export function decide(input) {
           speak: false,
           reason: 'cooldown',
           detail: `距上次主动开口 ${since.toFixed(1)} 分钟，不到 ${cfg.cooldownMinutes}`,
+          touchBeat: false,
         };
       }
     }
-    return { speak: true, reason: 'hard', detail: '有具体的事要说' };
+    return { speak: true, reason: 'hard', detail: '有具体的事要说', touchBeat: true };
   }
 
   // ── ⑤ 下限保护：太久没开口，强制允许一次 ────────────────
@@ -160,18 +177,20 @@ export function decide(input) {
       speak: true,
       reason: 'floor',
       detail: `已连续 ${input.quietStreak} 轮没开口，触到下限保护`,
+      touchBeat: true,
     };
   }
 
   // ── ⑥ 弱素材：掷色子 ────────────────────────────────────
   const r = random();
   if (r < cfg.dice) {
-    return { speak: true, reason: 'dice', detail: `色子 ${r.toFixed(3)} < ${cfg.dice}` };
+    return { speak: true, reason: 'dice', detail: `色子 ${r.toFixed(3)} < ${cfg.dice}`, touchBeat: true };
   }
   return {
     speak: false,
     reason: 'noMaterial',
     detail: `没硬素材，色子 ${r.toFixed(3)} ≥ ${cfg.dice}`,
+    touchBeat: true,
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-galatea",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Galatea — memory, heartbeat and continuity for DeepSeek Harness agents.",
   "repository": {
     "type": "git",