@modusensus/dsh-mneme 0.12.0 → 0.13.0

package/lib/config.js

@@ -1,6 +1,16 @@
 import z from "@deepseek-ai/schemastery";
 import { TYPE_DECAY_DEFAULTS } from "./heat.js";
 
+// #275 容量预警的阈值默认值，单独导出：service.getCapacityHealth 在 config 缺席
+// （直连调用方 / 测试传裸对象）时也要用同一套数字判级，不能另立一份——schema 的
+// .default({}) 只在「Config() 解析过」的路径上补值，裸 config 走不到。
+// 数字锚定 #275 议题里写的形态区间（活跃数百条、归档数千条），依据见 schema 处注释。
+export const CAPACITY_WARNING_DEFAULTS = Object.freeze({
+  dbSizeWarnMb: 256,
+  archivedRowsWarn: 5000,
+  archivedRatioWarn: 0.95
+});
+
 export const Config = z.object({
   // 记忆语言：生成记忆、注入标题与后台 LLM 提示词所用语言；'zh'（默认，
   // 行为不变）/ 'en'。启动时读入，切换后重启生效。
@@ -180,6 +190,18 @@ export const Config = z.object({
   // dreamMinIntervalMinutes 再开本键）。与 dreamPeakHours / dreamMinIntervalMinutes
   // 同族（节流阀，不新增任何 LLM 调用），故不进 LIGHT_MODE_OFF。
   autoDreamFailureBackoff: z.boolean().default(false),
+  // Issue #557（建议 2，opt-in 默认关 = 审计行逐字节一致）：dream 审计行的输入
+  // 快照瘦身。dream_runs.input 单行体积随记忆量涨（#557 实测平均 40-79 KB/轮，
+  // 绝大部分是 content），轮数又随天数涨，两者相乘超线性（报告库占 43% 的页）。
+  // 开启后 auto 轮的快照只留骨架（id/type/title/importance/updated_at，不含
+  // content）。巩固判定不回读审计行：LLM 输入由记忆库现算（prompt 不变），
+  // snapshot_hash 在内存里对含 content 的快照计算（receipt 完整性不变）；变的
+  // 只是离线回放——原文不在库里就重算不出 hash，#512「每一行都能回放一次巩固」
+  // 对瘦身轮降级为骨架级（#275 reclaim 清过 input 的库本就丢过这层，本键把同一
+  // 权衡前移到写入期）。organize 轮不经过这里（重放载荷走 organize.js 自己的
+  // saveDreamRun），写入期与 reclaim（run_type != 'organize'）同一条边界。
+  // storage-only、不新增任何 LLM 调用，不进 LIGHT_MODE_OFF（同上定性）。
+  dreamInputSummaryEnabled: z.boolean().default(false),
   // Issue #239（第 4 项，错峰队列）镜像到巩固：高峰期不做梦。与
   // summarizePeakHours 同一份时段语法（复用 src/summarize.js 的 parsePeakSpec /
   // isInPeakWindow / nextOffPeakAt，不另写解析器）：逗号分隔、可带星期前缀、支持
@@ -335,6 +357,26 @@ export const Config = z.object({
   // （= #230 的「管线对正文零读零写」）；与 memoryDir 一样是路径配置，不是
   // 行为开关，故不进 settings.js 的 feature flags 白名单、也不上面板。
   documentDir: z.string().default(""),
+  // 日记本（QQ 机器人写日记）：跨天惰性判定 + 启动补写，正文落
+  // `<memoryDir>/diaries/<项目键>/YYYY-MM-DD.md`，记忆库里留一条 document 指针行。
+  // 默认关=行为与此前一致；lightMode 强制关闭（它要调模型，与低资源档互斥）。
+  // 与 documentMemoryEnabled **成对但不相依**：关掉文档记忆只影响「能不能被检索到」，
+  // 正文照样写——那是用户自己的日记，不该被一个检索开关收走。
+  diaryEnabled: z.boolean().default(false),
+  // 日记根目录：空串 = 跟随 `<memoryDir>/diaries/`。与 documentDir 同一套路径规则
+  // （`~` 展开、绝对路径原样、相对路径落 memoryDir 下），同样是**路径配置不是行为
+  // 开关**，故不进 settings.js 白名单、也不上面板。
+  diaryDir: z.string().default(""),
+  // QQ 收件箱目录：空串 = 从 memoryDir 推（`<memoryDir>/../media/onebot`，本机即
+  // `D:\DSH\.dsh\media\onebot`）。推出不来就报 no-inbox-dir，绝不猜别的盘。
+  diaryInboxDir: z.string().default(""),
+  // 定时写（v0.13，桉桉 2026-11-09「日记本按理来说应该需要定时写，这个要存设置中」）：
+  // 每隔 N 分钟主动检查一次「今天是否还没写」，0 = 关（只在 turn/end 与启动时判，
+  // 即此前行为）。为什么要这一项：auto.js 原来只在回合结束时判跨天，用户整天不说话
+  // 就整天不写——日记不该取决于谁先开口。它仍然**不是 cron**：定时器只负责唤醒判定，
+  // 写不写在 compose 里按落盘日期去重，所以一天最多一篇，失败也只是 warn。
+  // 上限 1440（一天）：比一天更长的间隔没有意义，因为判定单位就是「天」。
+  diaryWriteEveryMinutes: z.natural().min(0).max(1440).default(0),
   // 隐式 keep（v0.4.4）：LLM 未提及的 snapshot 记忆自动补 {action:"keep"}，
   // 避免"未覆盖即全拒"白白浪费整轮 run。设为 false 时保留旧的严格校验
   // （未覆盖即拒绝整单）。
@@ -525,6 +567,33 @@ export const Config = z.object({
   conflictFreezeEnabled: z.boolean().default(false),
   // Maximum number of frozen conflicts to keep pending for manual review.
   conflictFreezeMaxPending: z.natural().min(1).max(1000).default(100),
+  // Issue #603 第 4 层（自动裁决档）：freeze 模式里相似度极高的同 scope 对直接
+  // 裁决（保留信息量更大的那条、归档另一条），不进人工队列——人只看模糊地带。
+  // 默认关：这是会归档记忆的自动动作，必须显式打开。
+  //
+  // ⚠️ Issue #616：这一档有三个已知边界，打开前先读，别当成「开了就清净」。
+  //
+  //  1) 阈值论证用的是早期快照，当前库上 0.95 等于不生效。
+  //     注释此前写「345 条有相似度、>=0.95 有 20 条（5.8%）」——2026-11-09 在
+  //     live 库重跑同口径：conflict_pending 全表 748 行，similarity 非 NULL 只有
+  //     11 行，其中 >=0.95 是 0 行，最高一对 0.914。这不是说阈值错了，是说
+  //     按 0.95 打开今晚一对都不会被判，用户会以为功能坏了。真要开，先按当前
+  //     分布重定阈值（配置下限 0.85），别沿用这两个数。
+  //
+  //  2) 它不是独立开关，是 freeze 分支的子节点。整段自动裁决都在
+  //     sleep.js 的 `if (config.conflictFreezeEnabled === true)` 里；关掉 freeze
+  //     会连它一起静默消失。面板上两个键看着平行，实际是父子。
+  //
+  //  3) 未标注 scope 会被判成同 scope。isCrossScopePair 走 scopeKeyOf，NULL 归一
+  //     成 null，null !== null 为 false，于是「归属未知」被当成「归属相同」。
+  //     live 库活跃 8259 行里 2710 行（32.8%）两个 scope 全 NULL，这批因此绕过了
+  //     「归属是用户的决定、永不自动」（v0.8.1 #170）这条守卫。改判据前不要打开。
+  //
+  // 另外 autoResolved/autoFailed 目前没有任何消费者（dream.js 只取 frozen），
+  // conflict_reviewed 台账也不记赢家、无 API 暴露——自动裁决了什么是看不见的。
+  // 可见性补齐之前，这一档只适合在能盯日志的前提下短时打开。
+  conflictAutoResolveEnabled: z.boolean().default(false),
+  conflictAutoResolveMinSimilarity: z.number().min(0.85).max(1).default(0.95),
 
   // --- entity gene (v0.3.0) -----------------------------------------------
   // Opt-in: when false (default) nothing in the pipeline extracts entities.
@@ -638,6 +707,22 @@ export const Config = z.object({
   sleepPatternLookbackDays: z.natural().min(1).max(90).default(30),
   // Max pattern memories minted per run (0 = disabled).
   sleepMaxPatternPerRun: z.natural().min(0).max(10).default(3),
+  // --- affective attribution (v0.13.0, issue #619) --------------------------
+  // Opt-in: when false (default) the affective phase does not run at all — no
+  // LLM call, no relations written. It exists so that a situational emotion
+  // ("she was anxious on defence day") can be stored as an occasion-bound
+  // relation instead of being generalised into "she is an anxious person".
+  sleepAffectiveEnabled: z.boolean().default(false),
+  // How many **independent sessions** a candidate must span before it may be
+  // promoted to a type=pattern trait. Below this it stays an occasion-bound
+  // affective_context relation. The floor is 2 on purpose: N=1 means a single
+  // occasion, and a single occasion is exactly what must never become a trait
+  // (that is the failure mode this phase exists to prevent).
+  sleepAffectiveTraitMinSessions: z.natural().min(2).max(10).default(3),
+  // Max affective_context relations written per run. Same role as
+  // sleepMaxPatternPerRun for the relation channel: a runaway model that
+  // "finds" an emotion in every memory must be capped, not trusted.
+  sleepAffectiveMaxRelationsPerRun: z.natural().min(0).max(50).default(10),
   // Optional LLM route override for sleep's bulk passes (empty = use dream
   // route / agent default model).
   sleepProvider: z.string().default("").description("sleep 深维护专用模型服务商，留空用巩固模型或当前模型。"),
@@ -760,6 +845,33 @@ export const Config = z.object({
     retentionDays: z.natural().min(1).max(3650).default(90)
   }).default({}),
 
+  // --- capacity warning (#275: 空间维度) ---------------------------------------
+  // 容量预警：库体积 / 归档区规模过线时在 /health 与面板上报（维护者 2026-10-21
+  // 接手口径：有 retentionDays 的时间维度，缺空间维度）。三个阈值都是**观察口**，
+  // 不是动作触发：没有任何周期性消费者（/health 被读到才算一次），预警也永不
+  // 自动归档 / 删除（#275 拍板：真删由人显式确认）——所以不设 enabled 总开关，
+  // 数字恒在 /health，阈值 0 = 显式关掉那一条检查。
+  //
+  // 默认值锚定议题里的形态区间，不是拍脑袋：
+  //   dbSizeWarnMb 256 —— 议题实测 55 MB 库 VACUUM 0.8s；按同议题的归档增速
+  //     （+143 行/天 ≈ 2.8 MB/天）留约 70 天余量，正落在「现在便宜、以后贵」
+  //     该开始看数字的量级；
+  //   archivedRowsWarn 5000 —— 「归档是数千条这个量级」的上沿（议题实测 2,400
+  //     时还没坏）；
+  //   archivedRatioWarn 0.95 —— 健康形态本身就落在 0.8~0.9（活跃数百 / 归档
+  //     数千，议题实测 0.90），0.9 会对着健康库天天报警；0.95 起才是「归档区
+  //     把活跃区吞掉」的形态。
+  // 判级实现在 service.getCapacityHealth，答复挂 /health 的 capacity 块；出口是
+  // 维护卡的无损回收（dsh-mneme reclaim，见 docs/STORAGE.md）与后续批次的归档区
+  // 周期处理。增速指标（归档净增速率）在 recall-stats 的 archive 块，不在这里重复。
+  capacityWarning: z.object({
+    dbSizeWarnMb: z.natural().min(0).max(1048576).default(CAPACITY_WARNING_DEFAULTS.dbSizeWarnMb),
+    archivedRowsWarn: z.natural().min(0).max(10000000).default(CAPACITY_WARNING_DEFAULTS.archivedRowsWarn),
+    // 浮点：与 conflictAutoResolveMinSimilarity 同款（面板整数控件吃不下小数，
+    // 走 FEATURE_FLAG_NUMBER_RANGES）。
+    archivedRatioWarn: z.number().min(0).max(1).default(CAPACITY_WARNING_DEFAULTS.archivedRatioWarn)
+  }).default({}),
+
   // --- write admission (#254) ------------------------------------------------
   // 写入准入：把「这条该不该进库」前移到 LLM 之前。与 memoryQualityFilter 的分工
   // 是时点不是判据——那个是**写入后**打分归档（扣分可以错，只影响排序与归档），
@@ -1049,6 +1161,25 @@ export const Config = z.object({
   // 占用轻量档预算的考量见键注释末句。
   profileFactsEnabled: z.boolean().default(false),
 
+  // chorography 面板闭环（2026-11-08 kb-qoder parity，契约见
+  // docs/plans/2026-11-08-kb-qoder-parity.md §3.1）。三个键都是「面板能不能替人
+  // 动手」的授权闸，与上面的 chorographyEnabled（子系统总闸）分层：总闸关着时
+  // 它们一律不生效，所以不必再进 LIGHT_MODE_OFF —— 轻量档要压的是「每轮付多少」，
+  // 而这三个键管的是「谁按下了重跑按钮」，关了也省不下一次调用，反倒让面板在
+  // 轻量档里静默少一块可操作区（同 chorographyEnabled 的定性与理由）。
+  //
+  // 过期的仓库在面板上直接刷新（POST /choro/run 的 refresh）。默认关：一次 T0 重跑
+  // 会扫整个仓库并重写 .chorography/ 下的页面，属于「改动工作区」的动作，不该在
+  // 没人要求时被面板顺手触发。
+  chorographyAutoRefresh: z.boolean().default(false),
+  // 面板发起 T1（POST /choro/t1）。默认**开**：这是面板闭环的主路径，关掉等于面板
+  // 上那个按钮永远是死的；真花钱的那一步仍由用户点按钮触发，且有
+  // chorographyEnabled 总闸在前面。需要「只读面板」的部署可以单独关它。
+  chorographyT1FromPanel: z.boolean().default(true),
+  // kb 子系统（知识库问答，B 线实现）的总闸。本车道只登记键与白名单，接线由后续
+  // 车道做——先有键才能让 /features 稳定暴露 false，客户端不至于静默少键。
+  kbEnabled: z.boolean().default(false),
+
   // #539 逐会话无痕：总开关默认关，保持旧用户行为；子代理选择器默认开，但总开关
   // 未开时不生效。手动名单是精确的 session id 匹配。
   sessionGateEnabled: z.boolean().default(false),
@@ -1063,6 +1194,9 @@ const LIGHT_MODE_OFF = [
   "entityExtractionEnabled",
   "autoDream",
   "sleepModeEnabled",
+  // #619：情感归因相位要调模型、且依赖实体抽取产出（抽取关掉就没有实体可挂边），
+  // 与低资源档双重互斥。默认本就是关，这里只是轻量预设再确认一次。
+  "sleepAffectiveEnabled",
   "rerankEnabled",
   "autoReindexOnBoot",
   "hybridInject",
@@ -1120,7 +1254,11 @@ const LIGHT_MODE_OFF = [
   // M.O. 自动沉淀：同样挂在 session/event 热路径上，而且解压会话日志是同步 I/O。
   // 轻量档的取向（小模型 / 小上下文 / 少常驻路径）与它直接冲突，预设里关掉；
   // 用户显式勾选仍然赢（合并顺序同上面几条）。
-  "actionNudgeEnabled"
+  "actionNudgeEnabled",
+  // 日记本：一次要调模型写一整段散文，且挂 session/event 热路径做跨天判定。
+  // 与低资源档（小模型 / 小上下文 / 少常驻路径）直接冲突，预设里关掉；
+  // 用户显式勾选仍然赢（合并顺序同上面几条）。
+  "diaryEnabled"
 ];
 
 /**

package/lib/continuity.js

@@ -1,4 +1,6 @@
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
+// Issue #611：图片块的文本口径（占位，不是空串），与 summarize.js 共用一份。
+import { contentToText } from "./attachment-text.js";
 
 // #249 N3（压缩边缘双落点）：上下文即将大幅精简前，抢救「正在做什么」。
 //
@@ -72,13 +74,12 @@ function isCompactionEdge(event) {
 // 与 summarize.js 的 collectMessages 同一个口径：只取公开文本块，reasoning 私有推理
 // 不进快照（快照可能被宿主重建进摘要）。刻意副本而不是导出——那边是会话蒸馏的内部
 // 细节，两边取文本的理由不同。
+//
+// Issue #611：图片块不再返回空串，改走 attachment-text 的占位口径。快照的全部意义
+// 就是「压缩后还能看出刚才在干什么」，而一张没被记下的截图恰恰是最容易丢的那部分
+// 上下文——用户在等你看图，压缩后却只剩一句「看这个」，这种快照比没有更误导。
 function textOf(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content
-    .map((block) => (typeof block === "string" ? block : (block?.type === "text" && typeof block.text === "string" ? block.text : "")))
-    .filter((s) => s)
-    .join("\n");
+  return contentToText(content);
 }
 
 // DSH 0.1.2-rc.1 起 Session 用 snapshotEvents()，兼容旧版 .events。这是**全量日志**

package/lib/diary/auto.js

@@ -0,0 +1,190 @@
+/**
+ * 日记的**触发侧**：让「跨天了该写一篇」变成自动发生，而不是等人想起来点按钮。
+ *
+ * 为什么单独一个文件：compose.js 是纯逻辑（采集/生成/落盘），触发时机、去重、
+ * 错误兜底是**宿主接线**问题。混在一起会让那层不再能被测试直接驱动。
+ *
+ * 三条执行侧边界（与 pipeline-nudge-auto.js 同一套口径）：
+ * - **不 cron，但可选定时唤醒**：判定发生在三处——turn/end、插件启动、以及
+ *   diaryWriteEveryMinutes > 0 时的定时器。定时器只负责「醒来问一句今天写了没」，
+ *   写不写仍由 compose 按落盘日期去重，所以一天最多一篇；缺省 0 = 关，只有前两处
+ *   （＝此前行为，整日不说话就不写）；
+ * - **一次只补一篇**：睡得久一点回来了也就补一篇，不许醒来一次补十篇烧配额；
+ * - **失败不冒泡**：session/event 那条链上还挂着摘要与续期，日记写砸了只能 warn。
+ */
+import { projectRootOf } from "../pipeline-runner.js";
+import { localDateString } from "./rollover.js";
+import { sessionAgentId } from "./session-provider.js";
+
+/** 同一项目两次判定的最短间隔：turn/end 密度很高，而一天只需写一篇。 */
+export const DIARY_MIN_INTERVAL_MS = 60 * 1000;
+
+export function createDiaryAutoRun({
+  ctx = null,
+  composer = null,
+  logger = null,
+  sessionGate = null,
+  now = () => Date.now(),
+  minIntervalMs = DIARY_MIN_INTERVAL_MS,
+  everyMs = 0,
+  listProjects = null
+} = {}) {
+  const log = logger || (ctx && ctx.logger) || null;
+  let disposed = false;
+  let timer = null;
+  /** 定时写的钟。与 timer（setTimeout(0) 的派发器）是两回事：那个只把待判项目挪到下一帧。 */
+  let ticker = null;
+  /** 每个项目最近一次判定时刻。注意是「判定」不是「写过」——写过与否在 compose 里按落盘判断。 */
+  const checkedAt = new Map();
+  /**
+   * 待判项目 → { session, trigger }。带会话是因为素材主来源就是它（见 compose 的
+   * session 参数）；带 trigger 是因为重扫要如实记账「这篇是谁叫醒的」。
+   */
+  const pending = new Map();
+
+  const normalize = (p) => {
+    let s = String(p).replace(/\\/g, "/").replace(/\/+$/, "");
+    if (/^[a-zA-Z]:\//.test(s)) s = s.toLowerCase();
+    return s;
+  };
+
+  const runOne = (projectRoot, trigger, session = null) => {
+    pending.delete(projectRoot);
+    if (disposed || !composer) return null;
+    checkedAt.set(normalize(projectRoot), now());
+    // session 与 agentId 一起传：素材取会话转录，声音取这个会话的人格卡。
+    // 两者必须来自同一个会话，否则会写出「A 的人格 + B 的素材」那种缝合怪。
+    const task = composer.compose({ trigger, projectRoot, session, agentId: sessionAgentId(session) });
+    // compose 是异步的（要等模型），绝不能返回给 session/event 的派发方去 await——
+    // 那会把回合收尾吊在模型延迟上（本机实测 p90 五十秒级）。
+    return Promise.resolve(task).catch((error) => {
+      log?.warn?.("[dsh-mneme] diary compose failed (" + projectRoot + "): " + String((error && error.message) || error));
+      return null;
+    });
+  };
+
+  const flush = () => {
+    timer = null;
+    if (disposed) return;
+    const first = pending.entries().next();
+    if (first.done) return;
+    const [projectRoot, queued] = first.value;
+    runOne(projectRoot, queued.trigger, queued.session);
+    if (pending.size > 0 && !disposed) defer();
+  };
+
+  const defer = () => {
+    if (disposed || timer) return;
+    // 当前这一帧是宿主的 turn/end 处理链。setTimeout(0) 挪到下一个宏任务，
+    // 宿主先收尾；unref 让退出不被这根定时器吊住。
+    timer = setTimeout(flush, 0);
+    if (typeof timer.unref === "function") timer.unref();
+  };
+
+  const schedule = (projectRoot, session = null, trigger = "rollover") => {
+    const key = normalize(projectRoot);
+    const last = checkedAt.get(key);
+    if (last !== undefined && now() - last < minIntervalMs) return;
+    if (pending.has(projectRoot)) return;
+    pending.set(projectRoot, { session, trigger });
+    defer();
+  };
+
+  const onSessionEvent = (session, event) => {
+    if (disposed) return;
+    if (sessionGate?.isOff(session)) return;
+    if (!event || event.type !== "turn/end") return;
+    const projectRoot = projectRootOf(session);
+    if (!projectRoot) return;
+    schedule(projectRoot, session);
+  };
+
+  const unsubscribe = ctx && typeof ctx.on === "function" ? ctx.on("session/event", onSessionEvent) : null;
+
+  /**
+   * 定时写：每隔 everyMs 醒来问一次「今天写了没」。
+   *
+   * 为什么需要它：原来的判定全挂在 turn/end 上，等于「你不说话它就不写」。桉桉
+   * 2026-11-09 说的「日记本按理来说应该需要定时写」就是这件事。唤醒后走的是同一条
+   * schedule → compose 路径，去重仍在 compose 里按落盘日期做，所以：
+   * - 一天最多一篇（跟手点「写一篇」共用那个去重）；
+   * - 失败只 warn，不打断宿主（session/event 那条链上还挂着摘要与续期）；
+   * - 醒来时不知道该扫哪个项目就什么都不做——宁可漏一次，不猜别人的项目根。
+   *
+   * 不用 setInterval 的理由：写完一篇要等模型（本机 p90 五十秒级），固定节拍会在
+   * 慢的那次之后立刻再来一次。这里改成「跑完再排下一次」，天然不重叠。
+   */
+  const tick = async () => {
+    if (disposed) return;
+    ticker = null;
+    if (!composer || everyMs <= 0) return;
+    try {
+      const projects = typeof listProjects === "function" ? listProjects() : [];
+      const list = Array.isArray(projects) ? projects.filter(Boolean) : [];
+      for (const projectRoot of list) {
+        if (disposed) break;
+        // 同一个项目由 turn/end 刚判过就不必再判（minIntervalMs 已经在 schedule 里
+        // 拦了一道，这里只是省掉一次 map 写入）。
+        schedule(projectRoot, null, "timer");
+      }
+    } catch (error) {
+      log?.warn?.("[dsh-mneme] diary timer scan failed: " + String((error && error.message) || error));
+    }
+    arm();
+  };
+
+  const arm = () => {
+    if (disposed || everyMs <= 0 || ticker) return;
+    ticker = setTimeout(() => {
+      Promise.resolve(tick()).catch((error) => {
+        log?.warn?.("[dsh-mneme] diary timer tick failed: " + String((error && error.message) || error));
+      });
+    }, everyMs);
+    // unref：不因为一根日记的钟让宿主退不出去。
+    if (typeof ticker.unref === "function") ticker.unref();
+  };
+
+  // 只有明确配了间隔才起钟。缺省 0 = 完全不起，行为与 v0.13 之前一致。
+  arm();
+
+  /**
+   * 启动补写：只补上次关宿主那段时间留下的那一篇。
+   *
+   * 为什么是启动而不是「每隔几小时」：宿主退出期间没有任何东西在跑，唯一能知道
+   * 「昨天没写」的时刻就是下次启动或下次说话。两处都判，效果对用户是一样的。
+   * 不知道该补哪个项目（启动时没有会话）→ 什么都不做，等第一次 turn/end。
+   */
+  const catchUp = (projects = []) => {
+    if (disposed || !composer) return Promise.resolve([]);
+    const list = Array.isArray(projects) ? projects.filter(Boolean) : [];
+    return Promise.all(
+      list.map((projectRoot) =>
+        Promise.resolve(composer.compose({ trigger: "startup", projectRoot })).catch((error) => {
+          log?.warn?.("[dsh-mneme] diary startup catch-up failed (" + projectRoot + "): " + String((error && error.message) || error));
+          return null;
+        })
+      )
+    );
+  };
+
+  const dispose = () => {
+    disposed = true;
+    pending.clear();
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (ticker) {
+      clearTimeout(ticker);
+      ticker = null;
+    }
+    if (typeof unsubscribe === "function") unsubscribe();
+  };
+  dispose.runNow = (projectRoot, trigger = "manual", session = null) => (disposed || !projectRoot ? null : runOne(projectRoot, trigger, session));
+  dispose.pendingCount = () => pending.size;
+  dispose.timerArmed = () => ticker !== null;
+  dispose.tickNow = () => (disposed ? Promise.resolve() : Promise.resolve(tick()));
+  dispose.catchUp = catchUp;
+  dispose.today = () => localDateString(new Date(now()));
+  return dispose;
+}