@modusensus/dsh-mneme 0.8.16 → 0.9.0

package/lib/config.js

@@ -91,7 +91,8 @@ export const Config = z.object({
   // feature_flags 的值永远优先于这里的默认值。
   injectGuidanceEnabled: z.boolean().default(true),
   // #249 N3（压缩边缘双落点）：上下文即将大幅精简前抢救「正在做什么」。默认关。
-  // 触发靠宿主自己的压缩事件（`compaction/start|summary|end`，都在事件白名单里），
+  // 触发只认「历史真的被折叠了」的压缩事件（summary / prune / 不带 error 的 end；
+  // 判定见 continuity.js 的 isCompactionEdge —— start 只是「试过」，带 error 的 end 是失败收尾），
   // 不自定一套阈值参数——「压缩边缘」由宿主定义，我们再校准一份只会与之漂移。
   // 为什么是「新时机 + 新表面」因而默认关：它往对话里**追加消息**（新的注入表面，
   // 参照实现里最容易累积成一堆历史的那类），并多写一张提案表。按 §10 判据，引入
@@ -481,6 +482,13 @@ export const Config = z.object({
   reflectionFailureTracking: z.boolean().default(true),
   reflectionUpdateMaxPerRun: z.natural().min(0).max(5).default(2),
   reflectionUpdateMinAgeHours: z.natural().min(0).max(168).default(24),
+  // failure_memories 的启动期保留期（天）。此前在 index.js 里写死 90，是这一族
+  // 四张启动期清理表里唯一没有键可陈述的一条（#275 伞下的欠账）。形态对齐
+  // recallRetentionDays：顶层扁平键、只从配置文件改；暂不进 settings.js 白名单，
+  // 面板可调是后续的事（那要同时补 api.js 的 NESTED 表与 client.js 的面板行）。
+  // 下限取 1 而非 0：这张表的用途是「挖掘重复出现的纠正模式」，窗口太短就只剩
+  // 最近一次；要彻底停掉清理应当显式关掉 reflectionFailureTracking。
+  reflectionFailureRetentionDays: z.natural().min(1).max(3650).default(90),
 
   // --- conflict freeze: manual review for conflicting memories (v0.2.1) ---
   // Opt-in by default: when true, conflicting memories are not auto-merged
@@ -828,10 +836,15 @@ export const Config = z.object({
 
   // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
   // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
-  // 逐字节不变。开启后 memory_save 写入 agent_scope（session header 的
-  // agentPreset）与 workspace_scope（registry 反查 canonical path，header.cwd
-  // 兜底，取不到 NULL——解析绝不阻塞写入），去重键扩展为 (type, title,
-  // agent_scope, workspace_scope, sensitivity)。检索侧加权/过滤在 A2/A3 落地。
+  // 逐字节不变。开启后**两条写入路径都自动盖章**（*_scope_source='auto'）：
+  // ① 工具调用（tools.js：memory_save / memory_update，显式参数改标 'explicit'）
+  // ② 机器提炼（summarize.js：会话蒸馏；合并进既有行时不盖章，作用域属于那一行
+  //    原来被提炼出来的语境——v0.9.0 补，此前只有工具路径盖章，于是「项目记忆」
+  //    在库里几乎不存在）。
+  // 两路的值同源：agent 维取 session header 的 agentPreset，workspace 维取
+  // registry 反查的 canonical path（header.cwd 兜底，取不到 NULL——解析绝不阻塞
+  // 写入），去重键扩展为 (type, title, agent_scope, workspace_scope, sensitivity)。
+  // 检索侧加权/过滤在 A2/A3 落地。
   // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
   scopeEnabled: z.boolean().default(false),
   // strictScope（A3）：硬过滤模式。关闭=A2 软隔离（他 scope 降权保留可见，
@@ -842,6 +855,19 @@ export const Config = z.object({
   // 打开才有意义（没有写入标注就无可过滤维度），但独立成键：可先开标注积累
   // 数据、观察 A2 加权质量后再切硬过滤。
   strictScope: z.boolean().default(false),
+
+  // --- v0.9.0 M.O.（Modus Operandi · 手法，beta）--------------------------
+  // 命名：M.O. = Modus Operandi，拉丁语「一个人一贯的做事方式」，缩写 M.O.；
+  // 也正是 org 词根 modus（modusensus）。界面主显示 M.O.，设置项 hint 第一句
+  // 给全名——缩写不靠注释解释，靠用户第一眼能看见全名。
+  // 这是客户端只读视图（做法图谱 + 对话行结算卡）的门控。API 的 effective 取值只认
+  // config 顶层/嵌套路径，schema 里没有这个键 → effective 静默少键 → 客户端读
+  // 不到就一个座位都不注册（#254 漏登记 NESTED_FLAG_PATHS 是同一个坑）。
+  // 默认关：beta 功能必须 opt-in，老用户行为逐字节不变。不进 LIGHT_MODE_OFF——
+  // 它只是只读视图、不引入任何重型后台路径，轻量档用户显式勾选仍然赢（预设
+  // 该关的是重型能力，不该替用户关掉一个纯 UI 入口）。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  actionPipelineEnabled: z.boolean().default(false)
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here

package/lib/continuity.js

@@ -15,9 +15,11 @@ import { createUserMessage } from "@deepseek-ai/dsh-llm";
 //    也只用本地字符串比较；门控成本为零。
 // 4. **触发器就是宿主真的压缩**，不自定一套阈值。宿主在 `agent/pre-step`（压力）与
 //    `agent/request-error`（溢出）两处触发压缩，我们只订阅压缩事件
-//    （`compaction/start|summary|end`，都在 @deepseek-ai/dsh-session 的事件白名单里
+//    （`compaction/*` 一族，都在 @deepseek-ai/dsh-session 的事件白名单里
 //     `lib/types/known-event-types.js:31-34`）。自定阈值会与宿主口径漂移，还多一份没
 //    人校准的参数；「压缩边缘」本来就有宿主自己下的定义。
+//    **但发过压缩事件不等于这段历史真的被折叠了** —— 压缩插件在每一步都会试一次，
+//    失败时没有任何东西需要抢救。记账口径见 isCompactionEdge。
 //
 // 落点顺序（为什么 pre-step 里挂得住）：宿主的压缩插件在它自己的 pre-step 监听器里先
 // `await compactIfNeeded(...)` 再 `return next()`，所以我们的监听器拿到 `next()` 结果
@@ -38,7 +40,34 @@ export const CONTINUITY_NOTICE_MAX = 900;
 /** 边缘表的兜底上限：只留序号、且有界——压缩完就没有下一次 pre-step 的会话不走消费路径。 */
 const MAX_TRACKED_EDGES = 50;
 
-const EDGE_EVENT_TYPES = new Set(["compaction/start", "compaction/summary", "compaction/end"]);
+/**
+ * 什么算「一个真的边缘」= 这段历史**真的被折叠了**。
+ *
+ * 这跟「有人发过压缩事件」不是同一个问题。压缩插件在**每一步**都会试一次压缩
+ * （`agent/pre-step` 里的 `compactIfNeeded`），所以 `compaction/start` 只在说
+ * 「有人试过」；尝试失败时没有任何东西需要抢救。按「试过就救」记账会得到一个
+ * **每步都触发**的触发器 —— 实测（2026-10-14，本机两个长会话、12,000+ 事件，
+ * 代理层把 dsh 原生压缩 100% 拒掉）：
+ *
+ *   · 按 `start|summary|end` 记账：1,287 次置位 / 359 次注入（4c28eaaa：2,895 / 625）
+ *   · 按「真落地」记账：  39 次置位 /  32 次注入（4c28eaaa：  161 /  74）→ 降 91% / 88%
+ *
+ * 三种「真落地」：
+ * - `compaction/summary`：宿主压缩成功才落（dsh-compaction-basic 的
+ *   `commitCompactionBody`，与成功路同步提交；失败路不落）。
+ * - `compaction/prune`：宿主把旧事件折叠出表面（dsh-compaction-tool-result-pruner），
+ *   是「表面真的变短了」最直接的证据。
+ * - `compaction/end`：**成败两条路都发**（同一份源码：失败路
+ *   `append("compaction/end", { ...lifecycle, error: errorChain(error) })`），
+ *   所以只有**不带 error** 的那条才算落地。
+ */
+function isCompactionEdge(event) {
+  const type = event?.type;
+  if (type === "compaction/summary" || type === "compaction/prune") return true;
+  if (type !== "compaction/end") return false;
+  const error = event?.data?.error;
+  return error === undefined || error === null || error === "";
+}
 
 // 与 summarize.js 的 collectMessages 同一个口径：只取公开文本块，reasoning 私有推理
 // 不进快照（快照可能被宿主重建进摘要）。刻意副本而不是导出——那边是会话蒸馏的内部
@@ -148,21 +177,21 @@ function noticeAlreadyInSurface(session, text) {
  * 保持"挂上就是开"的单一口径。
  */
 export function createContinuityRescue(ctx, store) {
-  // 待处理的边缘：sessionId → 压缩事件序号。压缩事件到达时置位，下一次 pre-step 消费后
+  // 待处理的边缘：sessionId → 压缩事件序号。**真落地**的压缩事件到达时置位，下一次 pre-step 消费后
   // 删除（同一个边缘绝不注入第二次）。只留序号、不留 Session：插件在宿主进程里只 apply
   // 一次、服务所有会话，握着 Session 就是握着它的全量日志不放——压缩完就收工、不再有
   // pre-step 是常见路径，这些条目永远走不到消费路径上。
   const edge = new Map();
 
   const unsubscribe = ctx.on("session/event", (session, event) => {
-    if (!EDGE_EVENT_TYPES.has(event?.type)) return;
+    if (!isCompactionEdge(event)) return;
     if (!session?.id) return;
     if (!edge.has(session.id) && edge.size >= MAX_TRACKED_EDGES) {
       // 兜底淘汰最旧的（Map 是插入序）：这里漏掉最坏也只少一次注入，不会无界增长。
       edge.delete(edge.keys().next().value);
     }
-    // 同一轮压缩会依次落 start/summary/end，后到的覆盖前一个：留着最后一个（更有
-    // 信息——summary 带摘要事件 seq），序号即触发证据。
+    // 同一轮可能出现多条落地事件（prune 与 end 并存），后到的覆盖前一个：留着最后一个，
+    // 序号即触发证据。
     edge.set(session.id, typeof event.seq === "number" ? event.seq : null);
   });
 

package/lib/dream/decisions.js

@@ -395,6 +395,12 @@ function casGuard(service, snapshot, ids) {
  *   provided, every decision target is CAS-checked against it and a decision
  *   computed from stale state is skipped and reported as a conflict instead of
  *   overwriting concurrent writes (item ①).
+ * @param config - pipeline config; `config.mintSource` (optional string) is the
+ *   provenance stamped on memories minted by `create` decisions. It is
+ *   read from the CALLER, never from the decision object: the LLM authors
+ *   `create` payloads and validateDecisions does not strip unknown fields, so
+ *   trusting `d.source` would let a model label its own output as human-written.
+ *   Absent/blank → saveWithDedupe's existing "manual" fallback (unchanged).
  * @returns {{ applied: number, conflicts: Array, failures: Array, committed: Array }}
  *   applied    - number of decisions/memories actually committed (archive counts
  *                each archived memory as one, merge/conflict/update count one).
@@ -484,7 +490,17 @@ function applyCreate(d, service, config = {}) {
   const body = evidence.length > 0
     ? STR.evidenceSuffix[language](content, evidence)
     : content;
-  const created = service.saveWithDedupe({ type, title, content: body, importance });
+  // mint 来源由调用方（管道）给，不从决策对象取——LLM 能自己写 d.source，
+  // 信它就等于让模型给自造条目盖「人写的」戳（见 applyDecisions 的 @param config）。
+  // 取不到就一个字段都不传，落回 saveWithDedupe 原有的兜底，行为与改前一致。
+  const mintSource = typeof config?.mintSource === "string" ? config.mintSource.trim() : "";
+  const created = service.saveWithDedupe({
+    type,
+    title,
+    content: body,
+    importance,
+    ...(mintSource ? { source: mintSource } : {})
+  });
   const memory = created?.memory;
   if (!memory) return "skipped"; // deduped/subsumed: nothing minted, clean no-op
   return { applied: 1, committed: { action: "create", id: memory.id, type } };

package/lib/dream/sleep.js

@@ -381,7 +381,11 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     allowedActions: actionSet === "full" ? null : LEGACY_ACTIONS
   });
   if (!ok) return { status: "failed", error: `invalid decisions: ${errors.join("; ")}`, skipped };
-  const { applied, failures, conflicts } = applyDecisions(decisions, service, logger, snapshot, config);
+  // 同 phasePatterns——本相位的 create 也落 source=sleep（默认档的
+  // LEGACY_ACTIONS 含 create，理论上可 mint）。
+  const { applied, failures, conflicts } = applyDecisions(
+    decisions, service, logger, snapshot, { ...config, mintSource: "sleep" }
+  );
   // Issue #126 review（Copilot）：事务内 service.update 会跳过 scheduleEmbed（txDepth>0），
   // 而 sleep 路径此前没有 dream 那样的 post-apply 索引维护——differentiate 的差异注记与
   // supersede 的归档都反映不到缓存向量，"注记进 embedding 防再判重复"就是空承诺。
@@ -525,7 +529,11 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     maxCreatePerRun: maxPatterns
   });
   if (!ok) return { status: "failed", error: `invalid decisions: ${errors.join("; ")}` };
-  const { applied, failures, conflicts } = applyDecisions(decisions, service, logger, snapshot, config);
+  // 本相位的 create 落 source=sleep。来源从管道给而非从决策对象取——见
+  // applyDecisions 的 @param config。
+  const { applied, failures, conflicts } = applyDecisions(
+    decisions, service, logger, snapshot, { ...config, mintSource: "sleep" }
+  );
   return {
     status: applied > 0 ? "ok" : "noop",
     scanned: memories.length,

package/lib/dream.js

@@ -1309,7 +1309,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // a target changed during the LLM call is skipped and reported as a
     // conflict instead of being overwritten (item ①). Frozen conflicts are
     // excluded from this list (they are parked, not applied).
-    const { applied, conflicts, failures, committed } = applyDecisions(applyList, service, logger, snapshot, config);
+    // mint 来源：主链路的 create 落 source=dream。来源从管道给而非从决策对象取——
+    // 见 applyDecisions 的 @param config。
+    const { applied, conflicts, failures, committed } = applyDecisions(
+      applyList, service, logger, snapshot, { ...config, mintSource: "dream" }
+    );
     // Per-record receipt chain: one row per actually-committed merge/conflict/
     // update verdict, stamped with the decision-basis digest + idempotency
     // counters (count_before → count_after). Written here, before the run audit

package/lib/entities/extractor.js

@@ -163,6 +163,10 @@ export async function extractEntities(memory, { store, config, callLLM, logger }
     if (config.entityExtractionModel) options.model = config.entityExtractionModel;
     const reasoning = config.entityExtractionReasoning;
     if (reasoning && reasoning !== "none") options.reasoningEffort = reasoning;
+    // #405: 审计行要能归因到具体记忆。extractor 只把 content 写进 prompt，id 这里顺
+    // options 交给 index.js 的 adapter（route 映射只认 provider/model，多余键不会进
+    // llm.stream）。拿不到 id 就不写这个键，adapter 侧照旧留空数组，不造虚账。
+    if (memory.id) options.memoryId = memory.id;
     const llmResponse = await callLLM(messages, options);
     
     if (!llmResponse) {

package/lib/index.js

@@ -14,7 +14,7 @@ import { createInjector } from "./inject.js";
 import { createPreInjectGate } from "./pre-inject-gate.js";
 import { createContinuityRescue } from "./continuity.js";
 import { createSummarizer } from "./summarize.js";
-import { createDreamScheduler } from "./dream.js";
+import { createDreamScheduler, describeStreamFailure } from "./dream.js";
 import { createSleepScheduler, runSleep } from "./dream/sleep.js";
 import { createApi } from "./api.js";
 import { createStandaloneApi } from "./api-standalone.js";
@@ -78,6 +78,11 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
       } catch { /* fall through to whatever route we already have */ }
     }
     const effort = options.reasoningEffort;
+    // #405: 审计行的 related_memory_ids 此前恒空、error_message 又被压成一句常量，
+    // 于是「哪条记忆没抽到实体、为什么」在库里查不出来（主库 735 条 error 行全是
+    // 同一句话）。id 由 extractor 顺 options 传下来——它只认 memory.content，不认
+    // id。口径同 write-admission:350：拿不到 id 就留空，绝不挂不存在的 id 造虚账。
+    const relatedMemoryIds = options.memoryId ? [options.memoryId] : [];
     // 没有解析出 provider/model 就没有可归属的模型——与 dream 的 resolveRoute
     // 无路由早退同口径，那种情况不写审计行。
     const modelId = route.provider && route.model ? `${route.provider}:${route.model}` : "";
@@ -89,7 +94,7 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
       const timestamp = new Date(startedAt).toISOString();
       // 记账是 best-effort：写审计行失败只 warn，绝不反噬抽取本身（CONTRIBUTING
       // 的 fail-safe 硬约定）。
-      const writeAudit = (status, errorMessage) => {
+      const writeAudit = (status, errorMessage, relatedMemoryIds = []) => {
         if (config?.llmAudit?.enabled === false || typeof service?.saveLlmAudit !== "function") return;
         // #372: modelId 为空 = 路由解析失败——此前整个 writeAudit 静默 return，
         // llm.stream 抛错也留不下任何行，正是 #108 要消灭的「零实体零日志」同款盲区。
@@ -111,7 +116,7 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
             duration_ms: Date.now() - startedAt,
             status,
             error_message: errorMessage,
-            related_memory_ids: []
+            related_memory_ids: relatedMemoryIds
           });
         } catch (auditError) {
           logger?.warn?.(`dsh-mneme: entity extraction llm audit write failed: ${String(auditError)}`);
@@ -136,7 +141,7 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
             if (Number.isFinite(o)) outputTokens = o;
           }
           if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
-            writeAudit("error", "llm stream aborted or errored");
+            writeAudit("error", describeStreamFailure(chunk.reason) || "llm stream aborted or errored", relatedMemoryIds);
             return undefined;
           }
         }
@@ -144,7 +149,7 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
         return text;
       })().catch((err) => {
         logger?.warn?.(`[dsh-mneme] entity extraction llm stream failed: ${String(err)}`);
-        writeAudit("error", String(err?.message ?? err));
+        writeAudit("error", String(err?.message ?? err), relatedMemoryIds);
         return undefined;
       });
     };
@@ -183,11 +188,6 @@ export const apply = (ctx, config) => {
   }
 
   const store = createStore(join(memoryDir, "memory.db"));
-  // Prune reflection failure rows older than 90 days on boot (best-effort, so
-  // the failure table never grows unbounded).
-  try {
-    store.deleteOldFailures(new Date(Date.now() - 90 * 86400000).toISOString());
-  } catch { /* non-fatal */ }
 
   // User-configurable settings (profile, rules, panel mode, standalone API
   // token) share the same SQLite file in dedicated tables, isolated from
@@ -226,6 +226,21 @@ export const apply = (ctx, config) => {
     cfg[objKey] = { ...(cfg[objKey] ?? {}), ...sub };
   }
 
+  // 失败表的启动期清理也放在装配之后（此前它在 createStore 之后、装配之前，写死
+  // 90 天）。保留期现在是显式配置键 reflectionFailureRetentionDays；等它进面板
+  // 白名单的那天，这里读的就是装配后的值，不用再改第二处。best-effort 语义不变：
+  // 清理失败不挡启动，否则一次锁表就能让插件起不来——但「不挡启动」不等于「可以
+  // 悄悄失败」：这一族的 recall_runs 清理当年就是静默蒸发，表涨到两万余行无人
+  // 察觉，所以本处与 llm_audit / distill_records / recall_runs 三处一样出声。
+  try {
+    const failureRetentionDays = Number.isInteger(cfg.reflectionFailureRetentionDays)
+      ? cfg.reflectionFailureRetentionDays
+      : 90;
+    store.deleteOldFailures(new Date(Date.now() - failureRetentionDays * 86400000).toISOString());
+  } catch (err) {
+    ctx.logger?.warn?.(`[dsh-mneme] failure-table retention purge failed: ${String(err)}`);
+  }
+
   // Bug8 的启动期清理放在装配之后：面板把 llmAudit.* 写进 kv、经 nestedFlags 合进
   // cfg，而写入侧（dream / summarize / 写入准入）读的都是装配后的 cfg——清理若读
   // rawCfg，面板改了保留期它不认，更糟的是「开不开审计」与写入侧可能取到不同的值
@@ -236,7 +251,9 @@ export const apply = (ctx, config) => {
       const retentionMs = Number.isInteger(cfg.llmAudit?.retentionDays) ? cfg.llmAudit.retentionDays : 90;
       store.deleteOldLlmAudits(new Date(Date.now() - retentionMs * 86400000).toISOString());
     }
-  } catch { /* non-fatal */ }
+  } catch (err) {
+    ctx.logger?.warn?.(`[dsh-mneme] llm_audit retention purge failed: ${String(err)}`);
+  }
 
   // #399 的启动期裁剪：与上面同款（读装配后的 cfg，理由同上——面板写的保留期必须
   // 与写入侧取到同一个值）。不同的一点：蒸馏原文留存默认关，而「默认关」在写入侧
@@ -250,7 +267,27 @@ export const apply = (ctx, config) => {
         : 90;
       store.clearDistillRecords(new Date(Date.now() - retentionMs * 86400000).toISOString());
     }
-  } catch { /* non-fatal */ }
+  } catch (err) {
+    ctx.logger?.warn?.(`[dsh-mneme] distill_records retention purge failed: ${String(err)}`);
+  }
+
+  // recall_runs 的滚动清理（v0.7.0 原设计，2026-10-14 找回）：与 llm_audit 同策略，
+  // 按 cfg.recallRetentionDays（默认 90 天）启动时清一次。读装配后的 cfg，理由与上面
+  // 两处一致 —— 写入侧取的是 cfg，清理侧若取 rawCfg，面板改的保留期就不生效。
+  // 这一对曾在 dd0ed78（v0.7.12 发布提交）里被整块弄丢，配置键与文档却一直留着，
+  // 实测 2026-10-13 那天从 16,041 涨到 20,510 行（一天四千余行，只增不减；
+  // 单给一个静态行数会随表腐坏，故带日期的区间才是可核对的说法）。注入行开始写真实 query 之后，这条从「表膨胀」
+  // 升级为「原话无限期留存」，所以必须与那次改动同批交付。
+  // 保留期语义是「天」（函数内部乘 86400000），清理失败只 warn，绝不挡插件启动。
+  try {
+    const recallRetentionDays = Number.isInteger(cfg.recallRetentionDays) ? cfg.recallRetentionDays : 90;
+    store.purgeRecallRunsOlderThan(recallRetentionDays);
+  } catch (err) {
+    // 这里必须真的出声。这一对当初是**静默**蒸发的：函数与调用一起没了、没人发现，
+    // 表就这么涨到两万余行。清理再失败一次而仍然不出声，同样的回归照样看不见——
+    // 「只 warn」不是修辞，是这族清理唯一的事后线索。
+    ctx.logger?.warn?.(`[dsh-mneme] recall_runs retention purge failed: ${String(err)}`);
+  }
 
   // 记忆语言（memory.language）：本实例逐层传入 inject / summarize / dream /
   // sleep / mirror，多实例（如 agent preset 内挂载）互不影响。

package/lib/inject.js

@@ -38,7 +38,12 @@ function visibleSeqsOf(session) {
 // session event log (same event shape summarize.js consumes) and returns the
 // most recent human message. Any failure degrades to "" — the injector then
 // falls back to the legacy rule-based pick, never breaking the render.
-function lastUserQuery(ctx) {
+//
+// v0.9.0：导出给 tools.js 的 memory_update 用。失败记录表的 query 与注入
+// 候选问的是同一件事——「当时到底想干什么」；这条取原话的路只该有一份实现。
+// 复制一份的代价本仓库付过几次（src/lib 平价、snapshotEvents 兼容层），所以
+// 这里只加 export，不改行为。
+export function lastUserQuery(ctx) {
   try {
     const session = ctx?.agent?.session;
     // DSH ≥0.1.2-rc only exposes events via snapshotEvents(); older builds