@kanadego/dsh-heartbeat 1.7.1 → 1.7.3

package/README.md

@@ -183,7 +183,9 @@ dsh plugin --profile web remove @kanadego/dsh-heartbeat
 
 | 插件版本 | 适配的 DSH | 说明 |
 |---|---|---|
-| **v1.7.1**（当前） | ≥ `0.1.2-rc.1` | 修复 `0.1.7` 下「心跳模式」预设丢失：预设改为声明式注册，不再依赖文件系统用户根 |
+| **v1.7.3**（当前） | ≥ `0.1.2-rc.1` | 修复心跳进行中拖住宿主关闭/更新的问题 |
+| v1.7.2 | ≥ `0.1.2-rc.1`（新增 `0.2.0-rc.1`） | 声明适配 `0.2.0-rc.1`，无行为改动 |
+| v1.7.1 | ≥ `0.1.2-rc.1` | 修复 `0.1.7` 下「心跳模式」预设丢失：预设改为声明式注册，不再依赖文件系统用户根 |
 | v1.7.0 | ≥ `0.1.2-rc.1`（在 `0.1.7-rc.2` 上验收） | 适配 0.1.7 的接口换代（设置接口 / 客户端服务 / 节律配置自持 / 会话消息源）；新增 psy 分区开关与节省 token 模式 |
 | v1.6.0 – v1.6.4 | ≥ `0.1.2-rc.1` | 素材闭环 + 视觉识别；修好 `0.1.5` 下节律配置保存不生效。**建议直接用 v1.6.4**：v1.6.3 的设置卡有渲染 bug，别停在那一版 |
 | v1.5.x | ≥ `0.1.2-rc.1` | 反刍投递改版（说不说的决定权交给目标会话里的 agent）；v1.5.1 元数据补全 |
@@ -195,26 +197,40 @@ dsh plugin --profile web remove @kanadego/dsh-heartbeat
 
 ## 版本更新
 
-### v1.7.1 · 2026-09-25（修复「心跳模式」预设丢失）
-
-**修掉升级 0.1.7 后心跳预设静默失效的问题**：0.1.7 起宿主不再从文件系统用户目录加载 agent 预设，旧的安装方式失效，症状是审计出现 `preset_install skipped-no-root`、界面报 `Unknown agent preset: heartbeat`、闲逛轮报 `tools.restrict unknown web_search`——预设没挂上，心跳 agent 成了"裸 agent"，连 `web_search` 都看不见。
-
-改为在插件的安装清单里**声明式**注册预设（与官方 standard 预设同机制），重启即注册，「心跳模式」重新出现在 Agent 预设页。`0.1.5` 及更早的宿主仍走原来的文件安装路径，两边都不断。
-
-- 预设内容与原先一致：上下文折叠组 + 唯一模型工具 `web_search`（不抓正文）；**无 persona 行**——部署人格与心跳提示词已足够，不能被 "You are a coding agent" 盖掉。
-- 升级后重启 DSH 即可，无需手动操作；本版读取的是内置声明，若 `~/.dsh/.agent-presets` 下那份是你手改过的，它不再生效。
+<details open>
+<summary><b>v1.7.x</b></summary>
+
+### v1.7.3 · 2026-09-29（修复：心跳拖住 DSH 关闭）
+
+修复心跳正在跑时 DSH 关不掉的问题——此前桌面端更新若恰逢一跳在跑，宿主等心跳结束等不到，更新会报「未能安全停止任务」。现在收到关闭信号，心跳会立刻停下手里这一跳，不再拖住宿主。
+
+### v1.7.2 · 2026-09-29（适配 DSH `0.2.0-rc.1`）
+
+声明适配 `0.2.0-rc.1`，无行为改动。
+
+### v1.7.1 · 2026-09-25（修复「心跳模式」预设丢失）
+
+**修掉升级 0.1.7 后心跳预设静默失效的问题**：0.1.7 起宿主不再从文件系统用户目录加载 agent 预设，旧的安装方式失效，症状是审计出现 `preset_install skipped-no-root`、界面报 `Unknown agent preset: heartbeat`、闲逛轮报 `tools.restrict unknown web_search`——预设没挂上，心跳 agent 成了"裸 agent"，连 `web_search` 都看不见。
+
+改为在插件的安装清单里**声明式**注册预设（与官方 standard 预设同机制），重启即注册，「心跳模式」重新出现在 Agent 预设页。`0.1.5` 及更早的宿主仍走原来的文件安装路径，两边都不断。
+
+- 预设内容与原先一致：上下文折叠组 + 唯一模型工具 `web_search`（不抓正文）；**无 persona 行**——部署人格与心跳提示词已足够，不能被 "You are a coding agent" 盖掉。
+- 升级后重启 DSH 即可，无需手动操作；本版读取的是内置声明，若 `~/.dsh/.agent-presets` 下那份是你手改过的，它不再生效。
+
 ### v1.7.0 · 2026-09-24
 
 - **现已适配 `0.1.7-rc.2`**（实机验收通过）
   - **设置接口**：0.1.7 换掉了插件配置界面的机制（改由宿主根据插件声明的字段自动生成表单），旧写法会失效。心跳现在自动探测宿主是哪一代，从三代接口里挑能用的——你跑哪版 DSH 都不用改配置。
   - **客户端服务**：0.1.7 删除了一个客户端旧服务，插件若仍声明它，整个 Web 界面会加载失败（症状：打开只看到「Failed to load plugins」，聊天区都进不去）。已移除该声明；设置卡其余分区不受影响。
   - **节律配置**：不再借宿主的设置接口读写，卡片编辑器直接写插件自己的配置文件，**点保存立即生效**（改间隔会当场重排下一跳），不用重启 DSH。优先级（低 → 高）：出厂默认 < 用户设置（`data/settings/ui.json`）< 宿主 patch 覆盖。
-  - **会话消息源**：0.1.7 的会话日志升级到 V4，不再接受旧版通用的消息来源标记——旧写法会让心跳轮次整轮写入失败。心跳已改用自有的来源标记，引擎室轮次恢复正常。
+  - **会话消息源**：0.1.7 的会话日志升级到 V4，不再接受旧版通用的消息来源标记——旧写法会让心跳轮次整轮写入失败。心跳已改用自有的来源标记，引擎室轮次恢复正常。
 - **psy 分区开关**：设置卡新增 psy 开关（默认关）。开启后画像合并才收 psy 分区条目；关闭时相关 ADD 一律拒收。值写在用户 policy 层（data/settings/policy.json），即时生效。
 - **节省 token 模式**：设置卡新增开关（默认关）。开启后，你离开（键盘/鼠标闲置 ≥30 分钟）或 Windows 锁屏时整跳暂停——不采维护、不闲逛、不反刍、不投递，一个 token 都不花；回来自动恢复。睡眠无需检测：睡眠中定时器本来不走，唤醒后闲置时长已覆盖睡眠期。探测失败一律放行（绝不因探测故障误暂停）。
 
+</details>
+
 <details>
-<summary><b>历史版本更新（v1.6.4 及更早）</b></summary>
+<summary><b>v1.6.x</b></summary>
 
 ### v1.6.4 · 2026-09-20
 
@@ -252,6 +268,11 @@ dsh plugin --profile web remove @kanadego/dsh-heartbeat
 - **UI**：心跳状态卡新增「插件版本」一行。
 - 测试 163 条全绿。
 
+</details>
+
+<details>
+<summary><b>v1.5.x</b></summary>
+
 ### v1.5.1 · 2026-09-16
 
 **元数据补全，无行为改动**——只影响安装与生态对接：
@@ -268,6 +289,11 @@ dsh plugin --profile web remove @kanadego/dsh-heartbeat
 - **素材包三段式投递**：①「这是心跳插件素材投递…」声明 ②素材清单 ③（3 条里 ≥2 条用过头时）「也可以说一句真心话」。目标会话里的 agent 按当下处境自己判断说不说、说哪条，话落到你读的会话，素材自动归账。
 - **表达提取健壮化**：修复素材投递偶发 `non-Chinese output discarded`——目标会话 agent 收到素材包后爱调工具时，末行落在收尾标签上被误拦。v1.5 起跳过工具收尾标签、取最后一个含中文的行，整段无中文才拒。
 
+</details>
+
+<details>
+<summary><b>v1.4.x</b></summary>
+
 ### v1.4.0 · 2026-09-13
 
 **兴趣范围 / 浏览时段卡片管理**（决策 D22）：
@@ -276,6 +302,11 @@ dsh plugin --profile web remove @kanadego/dsh-heartbeat
 - **首编继承出厂**：第一次成功编辑时，出厂兴趣与排程被完整复制进用户层再应用改动——出厂条目零丢失，此后卡片即唯一管理入口；只打开卡片或校验失败不会创建用户层；
 - 校验护栏：兴趣 ≤60 字 / 去重 / ≤32 条；窗口同日起始<结束 / 1–6 个 / 两两不重叠。
 
+</details>
+
+<details>
+<summary><b>v1.3.x</b></summary>
+
 ### v1.3.x · 2026-09-13
 
 **M7：状态栏与自研时间注入**——心跳的"在场感"从引擎室走进日常会话：
@@ -285,23 +316,41 @@ dsh plugin --profile web remove @kanadego/dsh-heartbeat
 - **状态文本零时间词（D21）**：时间感知归时间注入，状态栏只承载场景，把 KV-cache 成本钉在"场景变化"粒度；
 - UI：节律配置新增时间注入间隔与状态栏开关；v1.3.1 按评审修正了能力探测性能与轮次起源判定。
 
+</details>
+
+<details>
+<summary><b>v1.2.x</b></summary>
+
 ### v1.2.x · 2026-09-11/12
 
 适配 DSH `0.1.5-rc.2`：诊断兼容 `assistant/attempt` 事件形态（C19）、会话格式 v3 迁移适配（C20）、新增旧会话修复工具 `repair-v0-members.mjs`；v1.2.1 修复 0.1.5 下卡片 RPC 整体报 405（自定义通道在严格服务解析下不可用，迁移为 `/api` 精确路由，C21）。
 
+</details>
+
+<details>
+<summary><b>v1.1.x</b></summary>
+
 ### v1.1 · 2026-09-10
 
 适配 DSH `0.1.2-rc.1`：`Session.events` 移除、模型路由需显式传参、client 注册 id 强校验、会话标题投影迁移等六项宿主契约变化全数适配；**心跳预设改为首次启动自动安装**（一条 `dsh plugin add` 完成部署）；表达从"沉默是常态"改为**分寸优先**（默认倾向开口）；投递目标自动拉活；会话绑定投递/观察双开。
 
+</details>
+
+<details>
+<summary><b>v1.0.x</b></summary>
+
 ### v1.0.0 · 2026-09-05
 
 首个正式版：七相主循环、素材池 / 画像 / 闸门、DPAPI 加密与焚毁、审计留痕、设置页卡片。
 
+</details>
+
 <details>
-<summary>更早的开发阶段（v0.x 脚本外挂时代）</summary>
+<summary><b>v0.x（脚本外挂时代）</b></summary>
+
+### v0.x · 脚本外挂时代
 
 - 前身为 [kohaku-heartbeat](https://github.com/Kanadego/kohaku-heartbeat)——v1 脚本外挂形态，跑通"定时唤醒 + 采集 + 分寸表达"闭环后推倒重来为本插件形态。
-</details>
 
 </details>
 

package/cordis.patch.yml

@@ -13,7 +13,7 @@
     - id: heartbeat
       name: '@kanadego/dsh-heartbeat'
 
-# ── Agent preset heartbeat（0.1.7 声明式预设，v1.7.0）─────────────────
+# ── Agent preset heartbeat（0.1.7 声明式预设，v1.7.1）─────────────────
 # 0.1.7 起 agentPresets 名册不再挂载文件系统用户根（~/.dsh/.agent-presets），
 # 预设改为组合里的 @deepseek-ai/dsh-agent-preset 声明行（与官方 preset-standard
 # 同款机制）。内容 = assets/presets/heartbeat/agent.cordis.yml 的移植：

package/dist/index.js

@@ -64,7 +64,7 @@ import {
   removeBinding
 } from "./chunk-J6ZTRFFW.js";
 
-// node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.3/node_modules/@deepseek-ai/cosmokit/lib/index.js
+// node_modules/@deepseek-ai/cosmokit/lib/index.js
 function isNullable(value) {
   return value === null || value === void 0;
 }
@@ -83,6 +83,32 @@ function pick(source, keys, forced) {
   for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
   return result;
 }
+var write = /* @__PURE__ */ Symbol.for("cosmokit.volatile.write");
+function snapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (typeof value === "function") throw new TypeError("volatile config cannot contain functions");
+  if (value === null || typeof value !== "object") return value;
+  if (ancestors.has(value)) throw new TypeError("volatile config cannot contain cycles");
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) return Object.freeze(value.map((item) => snapshot(item, ancestors)));
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("volatile config objects must be plain objects or arrays");
+    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item, ancestors)])));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function createVolatile(value) {
+  let current = snapshot(value);
+  return Object.freeze({
+    get: () => current,
+    [write]: (value2) => {
+      current = value2;
+    }
+  });
+}
+function isVolatile(value) {
+  return typeof value === "object" && value !== null && write in value;
+}
 function is(type, value) {
   if (arguments.length === 1) return (value2) => is(type, value2);
   return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
@@ -161,24 +187,37 @@ function clone(source, refs = /* @__PURE__ */ new Map()) {
   return result;
 }
 function deepEqual(a, b, strict) {
-  if (a === b) return true;
-  if (!strict && isNullable(a) && isNullable(b)) return true;
-  if (typeof a !== typeof b) return false;
-  if (typeof a !== "object") return false;
-  if (!a || !b) return false;
-  function check(test, then) {
-    return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
-  }
-  return check(Array.isArray, (a2, b2) => a2.length === b2.length && a2.every((item, index) => deepEqual(item, b2[index]))) ?? check(is("Date"), (a2, b2) => a2.valueOf() === b2.valueOf()) ?? check(is("RegExp"), (a2, b2) => a2.source === b2.source && a2.flags === b2.flags) ?? check(isArrayBufferLike, (a2, b2) => {
-    if (a2.byteLength !== b2.byteLength) return false;
-    const viewA = new Uint8Array(a2);
-    const viewB = new Uint8Array(b2);
-    for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
-    return true;
-  }) ?? Object.keys({
-    ...a,
-    ...b
-  }).every((key) => deepEqual(a[key], b[key], strict));
+  const ancestors = /* @__PURE__ */ new Set();
+  function compare(a2, b2) {
+    if (a2 === b2) return true;
+    if (isVolatile(a2) || isVolatile(b2)) return isVolatile(a2) && isVolatile(b2);
+    if (!strict && isNullable(a2) && isNullable(b2)) return true;
+    if (typeof a2 !== typeof b2 || typeof a2 !== "object" || !a2 || !b2) return false;
+    if (ancestors.has(a2)) return false;
+    function check(test, then) {
+      return test(a2) ? test(b2) ? then(a2, b2) : false : test(b2) ? false : void 0;
+    }
+    ancestors.add(a2);
+    try {
+      return check(Array.isArray, (a3, b3) => {
+        if (a3.length !== b3.length) return false;
+        for (let index = 0; index < a3.length; index++) if (!compare(a3[index], b3[index])) return false;
+        return true;
+      }) ?? check(is("Date"), (a3, b3) => a3.valueOf() === b3.valueOf()) ?? check(is("URL"), (a3, b3) => a3.href === b3.href) ?? check(is("RegExp"), (a3, b3) => a3.source === b3.source && a3.flags === b3.flags) ?? check(isArrayBufferLike, (a3, b3) => {
+        if (a3.byteLength !== b3.byteLength) return false;
+        const viewA = new Uint8Array(a3);
+        const viewB = new Uint8Array(b3);
+        for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+        return true;
+      }) ?? ((!strict || [a2, b2].every((value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) && Object.keys({
+        ...a2,
+        ...b2
+      }).every((key) => compare(a2[key], b2[key])));
+    } finally {
+      ancestors.delete(a2);
+    }
+  }
+  return compare(a, b);
 }
 var Time;
 (function(Time2) {
@@ -250,7 +289,7 @@ var Time;
   Time2.template = template;
 })(Time || (Time = {}));
 
-// node_modules/.pnpm/@deepseek-ai+schemastery@3.18.2/node_modules/@deepseek-ai/schemastery/lib/index.mjs
+// node_modules/@deepseek-ai/schemastery/lib/index.mjs
 var kSchema = /* @__PURE__ */ Symbol.for("schemastery");
 var kValidationError = /* @__PURE__ */ Symbol.for("ValidationError");
 globalThis.__schemastery_index__ ??= 0;
@@ -427,6 +466,7 @@ Schema.prototype.pattern = function pattern(regexp) {
   return schema;
 };
 Schema.prototype.simplify = function simplify(value) {
+  if (isVolatile(value)) value = value.get();
   if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
   if (isNullable(value)) return value;
   if (this.type === "object" || this.type === "dict") {
@@ -484,12 +524,49 @@ for (const key of [
   };
   return schema;
 } });
+Schema.prototype.volatile = function volatile() {
+  if (this.meta.volatile) throw new TypeError("volatile schema is already wrapped");
+  return this.extra("volatile", true);
+};
 var resolvers = {};
+var checkedVolatile = /* @__PURE__ */ Symbol("checked-volatile-schema");
+function validateVolatileSchema(schema, path13 = [], blocked = false, seen = /* @__PURE__ */ new Map()) {
+  const states = seen.get(schema) ?? /* @__PURE__ */ new Set();
+  if (states.has(blocked)) return;
+  states.add(blocked);
+  seen.set(schema, states);
+  if (schema.meta?.volatile && blocked) throw new ValidationError("volatile fields require a fixed object path without an enclosing volatile field", { path: path13 });
+  const nested = blocked || !!schema.meta?.volatile;
+  if (schema.dict) for (const [key, child] of Object.entries(schema.dict)) validateVolatileSchema(child, [...path13, key], nested, seen);
+  if (schema.sKey) validateVolatileSchema(schema.sKey, [...path13, "<key>"], true, seen);
+  if (schema.inner && (schema.type !== "lazy" || schema.inner[kSchema])) validateVolatileSchema(schema.inner, [...path13, "*"], true, seen);
+  if (schema.list) for (let index = 0; index < schema.list.length; index++) validateVolatileSchema(schema.list[index], [...path13, String(index)], true, seen);
+}
 Schema.extend = function extend(type, resolve2) {
   resolvers[type] = resolve2;
 };
 Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
   if (!schema) return [data];
+  if (!options[checkedVolatile]) {
+    validateVolatileSchema(schema, options.path);
+    options = {
+      ...options,
+      [checkedVolatile]: true
+    };
+  }
+  if (schema.meta?.volatile) {
+    const inner = Schema(schema);
+    inner.meta = {
+      ...schema.meta,
+      volatile: false
+    };
+    const [value, adapted] = Schema.resolve(data, inner, options, strict);
+    try {
+      return [createVolatile(value), adapted];
+    } catch (error) {
+      throw new ValidationError(error instanceof Error ? error.message : String(error), options);
+    }
+  }
   if (options.ignore?.(data, schema)) return [data];
   if (isNullable(data) && schema.type !== "lazy") {
     if (schema.meta.required) throw new ValidationError(`missing required value`, options);
@@ -597,6 +674,7 @@ Schema.extend("lazy", (data, schema, options, strict) => {
       ...schema.meta,
       ...schema.inner.meta
     };
+    validateVolatileSchema(schema.inner, options.path, true);
   }
   return Schema.resolve(data, schema.inner, options, strict);
 });
@@ -696,7 +774,7 @@ function property(data, key, schema, options) {
   } catch (e) {
     if (!options?.autofix) throw e;
     delete data[key];
-    return schema.meta.default;
+    return schema.meta.volatile ? createVolatile(schema.meta.default) : schema.meta.default;
   }
 }
 Schema.extend("array", (data, { inner, meta }, options) => {
@@ -1026,7 +1104,7 @@ function collectPulse(guard, paths, rules, fgProcess = null, now = /* @__PURE__
   const idle = probeIdle(guard, paths);
   const windowClass = classifyProcess(fgProcess, rules);
   const t = timeContext(now);
-  const snapshot = {
+  const snapshot2 = {
     takenAt: now.toISOString(),
     idleSeconds: idle,
     presence: presenceOf(idle, windowClass),
@@ -1037,24 +1115,24 @@ function collectPulse(guard, paths, rules, fgProcess = null, now = /* @__PURE__
     festival: t.festival
   };
   try {
-    fs3.writeFileSync(path3.join(paths.dataDir, "envpulse.json"), JSON.stringify(snapshot, null, 1), "utf8");
+    fs3.writeFileSync(path3.join(paths.dataDir, "envpulse.json"), JSON.stringify(snapshot2, null, 1), "utf8");
   } catch {
   }
-  writePulseStream(paths, snapshot);
-  return snapshot;
+  writePulseStream(paths, snapshot2);
+  return snapshot2;
 }
-function writePulseStream(paths, snapshot) {
+function writePulseStream(paths, snapshot2) {
   try {
     appendAuditLine(path3.join(paths.logsDir, "envpulse.jsonl"), {
       event: "pulse",
-      takenAt: snapshot.takenAt,
-      idleSeconds: snapshot.idleSeconds,
-      presence: snapshot.presence,
-      windowClass: snapshot.windowClass,
-      daypart: snapshot.daypart,
-      weekday: snapshot.weekday,
-      isWeekend: snapshot.isWeekend,
-      festival: snapshot.festival
+      takenAt: snapshot2.takenAt,
+      idleSeconds: snapshot2.idleSeconds,
+      presence: snapshot2.presence,
+      windowClass: snapshot2.windowClass,
+      daypart: snapshot2.daypart,
+      weekday: snapshot2.weekday,
+      isWeekend: snapshot2.isWeekend,
+      festival: snapshot2.festival
     });
   } catch {
   }
@@ -1799,8 +1877,8 @@ function sessionEvents(session) {
   if (!session) return [];
   if (typeof session.snapshotEvents === "function") {
     try {
-      const snapshot = session.snapshotEvents();
-      if (Array.isArray(snapshot)) return snapshot;
+      const snapshot2 = session.snapshotEvents();
+      if (Array.isArray(snapshot2)) return snapshot2;
     } catch {
     }
   }
@@ -1815,6 +1893,7 @@ var IDLE_WAIT_TIMEOUT_MS = 24e4;
 var EXPRESSION_IDLE_WAIT_MS = 6e5;
 var agentPromise = null;
 var beating = false;
+var beatCancel;
 var lastBeat = null;
 function getLastBeat() {
   return lastBeat;
@@ -2468,6 +2547,14 @@ async function beat(deps) {
     appendAuditLine(paths.logsDir + "/heartbeat.jsonl", { event: "beat_start" });
     const beatStart = new Date(now).toISOString();
     const agent = await ensureAgent(deps);
+    if (agent) {
+      beatCancel = () => {
+        try {
+          agent.cancel?.();
+        } catch {
+        }
+      };
+    }
     let wandered = false;
     if (agent) {
       deferredRetries = 0;
@@ -2506,6 +2593,7 @@ async function beat(deps) {
     }
   } finally {
     beating = false;
+    beatCancel = void 0;
   }
 }
 function startOrchestrator(deps) {
@@ -2541,7 +2629,12 @@ function startOrchestrator(deps) {
     return () => {
       if (timer) clearInterval(timer);
       if (first) clearTimeout(first);
-      appendAuditLine(deps.paths.logsDir + "/heartbeat.jsonl", { event: "orchestrator_disposed" });
+      const cancelledInFlight = beating && beatCancel !== void 0;
+      try {
+        beatCancel?.();
+      } catch {
+      }
+      appendAuditLine(deps.paths.logsDir + "/heartbeat.jsonl", { event: "orchestrator_disposed", beatCancelled: cancelledInFlight });
       deps.ctx.logger.info("heartbeat: orchestrator timer disposed");
     };
   }, "heartbeat: timer");