@modusensus/dsh-mneme 0.5.1 → 0.5.3

package/README.md

@@ -5,12 +5,32 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Awesome](https://awesome-dsh-plugin.com/badge.svg)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-593%20passed-success)](https://github.com/modusensus/dsh-mneme)
+[![tests](https://img.shields.io/badge/tests-603%20passed-success)](https://github.com/modusensus/dsh-mneme)
 
 > 给 DeepSeek Harness 的跨会话记忆插件：让 Agent 记住你、记住项目、自动整理记忆。**Mneme**（Μνήμη）——希腊记忆女神 Mnemosyne 之名，掌管记忆与梦境，正如 autoDream 在后台巩固记忆。
 
 `dsh-mneme` 是一个 [DeepSeek Harness (DSH)](https://github.com/deepseek-ai/deepseek-harness) 插件，为 Agent 提供持久的跨会话记忆能力。它借鉴了 Claude 的 **Dream 机制** 与 cc-haha / Claude Code 的 **autoDream** 实现思路——不仅**存储**记忆，还会**自动巩固**（去重、合并、冲突裁决、摘要生成），让记忆库越用越精炼。
 
+## ⏱️ 30 秒理解
+
+**一句话**：给 Agent 装上跨会话记忆——记住你、记住项目，并在后台自动整理，越用越懂你。
+
+| ① 写入 | ② 存储 | ③ 进化 |
+|--------|--------|--------|
+| 对话中模型主动记录（`memory_save`）；会话结束自动提炼（`autoSummarize`） | SQLite 主库 + 人类可编辑 Markdown 镜像；实体 / 属性 / 时间轴三层结构化 | 新会话自动注入相关记忆；autoDream 后台去重 / 合并 / 归档，记忆库自我精炼 |
+
+```bash
+# 30 秒上手
+dsh plugin --profile web add @modusensus/dsh-mneme
+dsh web
+```
+
+**它不是什么**（边界声明）：
+
+- 不是向量数据库——语义搜索是可选增强，默认零额外依赖
+- 不替代会话日志——它存的是「值得跨会话记住的」精炼知识
+- 不改变模型本身——进化的是记忆库与每次注入的上下文
+
 ## ✨ 功能
 
 ### 记忆存储（SQLite + Markdown 镜像）
@@ -64,7 +84,7 @@
 | 中等（1 万-5 万字） | `65536` |
 | 大型（5 万字以上） | `131072`（上限） |
 
-> 若使用**思考型模型**（如 DeepSeek-R1 类），模型可能把全部预算花在 reasoning 上导致正文为空（日志出现 `no json array in llm output`）。此时把 `dreamReasoningEffort` 设为 `low` 可压制推理开销、把预算留给正文输出；sleep 侧对应 `sleepReasoningEffort`。默认 `none` 不传该字段，完全沿用模型自身默认，行为与旧版本一致。
+> 若使用**思考型模型**（如 deepseek-v4-flash / DeepSeek-R1 类），模型可能把全部预算花在 reasoning 上导致正文为空（日志出现 `no json array in llm output`）。此时把 `dreamReasoningEffort` 设为 `off` 显式关闭思考（实测 8192 token 预算不再被推理吃光，输出恢复正常）；sleep 侧对应 `sleepReasoningEffort`。默认 `none` 不传该字段，完全沿用模型自身默认，行为与旧版本一致。
 
 ### Sleep Mode 系统级睡眠 💤（v0.4.0，opt-in）
 
@@ -277,8 +297,8 @@ dsh web
 | `dreamThresholdChars` | `5000` | 触发整理的总字符阈值 |
 | `dreamDelayMs` | `2000` | 整理异步延迟（去抖） |
 | `dreamProvider` / `dreamModel` | 空 | dream 的 LLM 路由回退（默认用 agent 默认模型） |
-| `dreamMaxTokens` | `4096` | dream LLM 调用最大 token 数（上限 131072；大记忆量建议调大，见下方调优指南） |
-| `dreamReasoningEffort` | `none` | dream LLM 推理强度透传：`low` / `medium` / `high` / `none`（`none`=不传该字段，使用模型默认；思考型模型预算被推理耗尽导致正文为空时可设 `low`） |
+| `dreamMaxTokens` | `8192` | dream LLM 调用最大 token 数（上限 131072；大记忆量建议调大，见下方调优指南） |
+| `dreamReasoningEffort` | `none` | dream LLM 推理强度透传：`off` / `low` / `medium` / `high` / `none`（`off`=显式关闭思考，思考型模型（如 deepseek-v4-flash）必须用它，否则推理会烧光 token 预算导致正文为空；`none`=不传该字段，沿用模型默认） |
 | `apiToken` | 空 | 可选 API 鉴权 token；设置后写操作与密钥接口要求 `Authorization: Bearer <apiToken>` |
 | `embedProvider` | `openai` | 语义后端：`openai`（默认，兼容 v0.1）/ `local`（ONNX 离线）/ `ollama` |
 | `localEmbedModel` | `Xenova/bge-small-zh-v1.5` | 本地 ONNX embedding 模型 |
@@ -367,7 +387,7 @@ src/
 lib/
 ├── client.js         # Web 面板（手写 ModuleLoader bundle）
 └── *.js              # src 的同步分发产物
-test/                 # 593 个 node:test 测试（含审计与三轴线压测不变量）
+test/                 # 603 个 node:test 测试（含审计与三轴线压测不变量）
 scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压测 · sync-lib.js 同步 · benchmark-recall.js 召回基准
 ```
 
@@ -376,7 +396,7 @@ scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 593 个测试
+npm test           # 运行 603 个测试
 npm run stress     # 三轴线压测：长会话检索 / 冲突仲裁 / 多 Agent 并发（离线 mock LLM）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```

package/lib/config.js

@@ -19,11 +19,13 @@ export const Config = z.object({
   dreamModel: z.string(),
   dreamMaxTokens: z.natural().min(256).max(131072).default(8192),
   // Pass-through reasoning effort for dream's LLM calls. 'none' (default)
-  // omits the field so the provider's own default applies; low/medium/high
-  // are forwarded verbatim. Useful to cap reasoning spend on thinking-type
-  // models that would otherwise drain the whole token budget and return an
-  // empty body ("no json array in llm output").
+  // omits the field so the provider's own default applies; 'off' explicitly
+  // disables thinking — REQUIRED for thinking-type models (deepseek-v4-flash
+  // etc.) that would otherwise drain the whole token budget into reasoning and
+  // return an empty body ("no json array in llm output"); low/medium/high are
+  // forwarded verbatim to cap reasoning spend.
   dreamReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),
@@ -197,9 +199,11 @@ export const Config = z.object({
   sleepProvider: z.string().default(""),
   sleepModel: z.string().default(""),
   // Pass-through reasoning effort for sleep's LLM passes, same semantics as
-  // dreamReasoningEffort: 'none' (default) omits the field; low/medium/high
-  // are forwarded verbatim.
+  // dreamReasoningEffort: 'none' (default) omits the field; 'off' explicitly
+  // disables thinking (thinking-type models would burn the whole budget on
+  // reasoning); low/medium/high are forwarded verbatim.
   sleepReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),

package/lib/dream.js

@@ -1,7 +1,7 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts } from "./dream/clustering.js";
 import { createHash, randomUUID } from "node:crypto";
-export { validateDecisions, applyDecisions };
+export { validateDecisions, applyDecisions, normalizeDecisions };
 
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -40,6 +40,95 @@ function extractJsonArray(text) {
   }
   return null;
 }
+
+/**
+ * Field-name drift guard (v0.5.3): thinking-type models (deepseek-v4-flash
+ * etc.) occasionally ignore the prompt's exact decision schema and emit alias
+ * keys —实测方案 A 输出 "consolidation"/"target_ids"、方案 B 输出
+ * "action"/"targetIds"，都不是插件要求的 "action"/"ids"。normalizeDecisions
+ * 在 validateDecisions 之前把常见变体重写回规范字段名，让"字段名不听话但
+ * 语义正确"的输出仍可被应用，而不是整单被拒。覆盖三类漂移：
+ *   1. 整个 body 是包在对象里的数组（{consolidation:[...]} /
+ *      {decisions:[...]} / {actions:[...]}）；
+ *   2. 决策对象用了别名键（target_ids→ids、keep_source→keepSource、
+ *      winner_id→winner、targetIds→ids 等）；
+ *   3. action 值用了同义词（archived→archive、consolidation→merge 等）。
+ * 无归一化必要时原样返回（null→null，调用方"no json array"分支不受影响）。
+ */
+const FIELD_ALIASES = {
+  // "consolidation" 也可作 action 键（实测 deepseek-v4-flash 这么写过）；
+  // 但 normalizeOne 对 action 键做字符串过滤，{consolidation:[...]} 这种
+  // wrapper 数组不会被误当成 action（顶层 WRAPPER_KEYS 负责解包）。
+  action: ["action", "decision", "operation", "op", "action_type", "actionType", "mode", "consolidation"],
+  // 注意：action 别名不含 "type"——create 决策的 type 是合法的记忆类型字段，
+  // 不能误当 action。
+  ids: ["ids", "target_ids", "targetIds", "targets", "memory_ids", "memoryIds", "id_list", "idList", "memories"],
+  reason: ["reason", "rationale", "why", "comment", "note", "explanation"],
+  importance: ["importance", "priority", "weight", "level", "score"],
+  keepSource: ["keepSource", "keep_source", "source_id", "sourceId", "keeper", "keep_id", "keepId"],
+  winner: ["winner", "winner_id", "winnerId", "win_id", "winId", "preferred", "primary"],
+  loser: ["loser", "loser_id", "loserId", "lose_id", "loseId", "drop_id", "dropId", "archive_id", "archiveId"],
+  title: ["title", "new_title", "newTitle", "merged_title", "mergedTitle", "merge_title", "mergeTitle"],
+  content: ["content", "new_content", "newContent", "merged_content", "mergedContent", "merge_content", "mergeContent"],
+  evidence: ["evidence", "evidence_ids", "evidenceIds"]
+};
+
+// 保守的 action 值同义词：只收语义无歧义、不可能被误认为记忆类型/其他 action 的映射。
+const ACTION_SYNONYMS = {
+  archived: "archive",
+  remove: "archive",
+  delete: "archive",
+  combine: "merge",
+  consolidation: "merge",
+  consolidate: "merge",
+  modify: "update",
+  edit: "update"
+};
+
+const WRAPPER_KEYS = ["consolidation", "decisions", "actions", "results", "updates", "list", "data"];
+
+/** 把单个决策对象重写到规范字段名；非对象原样返回。 */
+function normalizeOne(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const d = {};
+  const consumed = new Set();
+  for (const [canon, aliases] of Object.entries(FIELD_ALIASES)) {
+    for (const key of aliases) {
+      if (key in raw && raw[key] !== undefined && raw[key] !== null) {
+        // action 必须是字符串——{consolidation:[...]} 的 wrapper 数组跳过。
+        if (canon === "action" && Array.isArray(raw[key])) continue;
+        d[canon] = raw[key];
+        consumed.add(key);
+        break;
+      }
+    }
+  }
+  // 保留未被别名消费的原始键（create 的 type、未来字段）原样透传。
+  for (const key of Object.keys(raw)) {
+    if (!consumed.has(key)) d[key] = raw[key];
+  }
+  if (typeof d.action === "string") {
+    const low = d.action.toLowerCase();
+    if (ACTION_SYNONYMS[low] !== undefined) d.action = ACTION_SYNONYMS[low];
+  }
+  // ids 若被写成单个字符串则包成数组（validateDecisions 要求数组）。
+  if (d.ids !== undefined && typeof d.ids === "string") d.ids = [d.ids];
+  return d;
+}
+
+/** 归一化 LLM 决策 body（数组 / 包裹对象 / 单个决策对象），null 原样返回。 */
+function normalizeDecisions(raw) {
+  if (!raw) return raw;
+  if (Array.isArray(raw)) return raw.map(normalizeOne).filter((d) => d && typeof d === "object");
+  if (typeof raw === "object") {
+    for (const key of WRAPPER_KEYS) {
+      if (Array.isArray(raw[key])) return normalizeDecisions(raw[key]);
+    }
+    // 单个决策对象 → 包成单元素数组（validateDecisions 要求数组）。
+    return [normalizeOne(raw)];
+  }
+  return raw;
+}
 const SUMMARY_PROMPT = `你是记忆库摘要助手。根据整理后的记忆，生成一段 150-200 字的记忆库总览，覆盖：用户偏好、活跃项目、关键决策。之后作为会话上下文注入。只输出摘要文本，不要其他内容。`;
 
 const CONSOLIDATION_PROMPT = `你是记忆库整理助手。下面是全部记忆条目（id、类型、标题、内容、重要性、更新时间）。
@@ -616,7 +705,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       return finish({ ok: false, error: "llm failed", summary: false });
     }
 
-    const decisions = extractJsonArray(decisionText);
+    // v0.5.3 字段名归一化兜底：thinking 模型可能输出别名键/wrapper 对象，
+    // 在 validateDecisions 之前重写到规范字段名，语义正确但 schema 不听话的
+    // 输出不再整单被拒。
+    const decisions = normalizeDecisions(extractJsonArray(decisionText));
     if (!Array.isArray(decisions)) {
       logger?.warn?.(`dsh-mneme dream: no json array in llm output (raw length ${decisionText?.length ?? 0})`);
       return finish({ ok: false, error: "no json array in llm output", summary: false });

package/lib/service.js

@@ -811,6 +811,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       tags: memory.tags ?? [],
       importance: memory.importance ?? 3,
       source: memory.source ?? "manual",
+      // Provenance (v0.5.x): birth session rides through the create path; the
+      // merge path above preserves the original row's session_id untouched.
+      session_id: memory.session_id ?? undefined,
       ...(quality ? { quality_score: quality.score } : {})
     });
     const result = applyQualityDisposition(created, quality, qf);

package/lib/store.js

@@ -12,6 +12,7 @@ CREATE TABLE IF NOT EXISTS memories (
   forgotten   INTEGER NOT NULL DEFAULT 0,
   archived    INTEGER NOT NULL DEFAULT 0,
   source      TEXT,
+  session_id  TEXT,
   content_history TEXT,
   embedding   TEXT,
   epistemic_status TEXT NOT NULL DEFAULT 'subjective',
@@ -321,6 +322,7 @@ function toRow(row) {
     forgotten: row.forgotten === 1,
     archived: row.archived === 1,
     source: row.source ?? undefined,
+    session_id: row.session_id ?? undefined,
     content_history: parseJsonArray(row.content_history),
     quality_score: row.quality_score !== null && row.quality_score !== undefined ? Number(row.quality_score) : undefined,
     epistemic_status: row.epistemic_status ?? "subjective",
@@ -571,6 +573,7 @@ export function createStore(path) {
   addColumn("memories", "epistemic_status", "ALTER TABLE memories ADD COLUMN epistemic_status TEXT NOT NULL DEFAULT 'subjective'");
   addColumn("memories", "content_history", "ALTER TABLE memories ADD COLUMN content_history TEXT");
   addColumn("memories", "quality_score", "ALTER TABLE memories ADD COLUMN quality_score REAL");
+  addColumn("memories", "session_id", "ALTER TABLE memories ADD COLUMN session_id TEXT");
 
   // Legacy dream_runs without policy_epoch → backfill with the default epoch.
   addColumn("dream_runs", "policy_epoch", "ALTER TABLE dream_runs ADD COLUMN policy_epoch INTEGER NOT NULL DEFAULT 0");
@@ -657,8 +660,8 @@ export function createStore(path) {
       : inferEpistemicStatus(memory);
     runAtomically(() => {
       db.prepare(
-        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, content_history, quality_score, embedding, epistemic_status, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, session_id, content_history, quality_score, embedding, epistemic_status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ).run(
         id,
         type,
@@ -668,6 +671,7 @@ export function createStore(path) {
         importance,
         memory.archived ? 1 : 0,
         memory.source ?? null,
+        memory.session_id ?? null,
         JSON.stringify(memory.content_history ?? []),
         Number.isFinite(memory.quality_score) ? memory.quality_score : null,
         embedding,

package/lib/summarize.js

@@ -182,7 +182,11 @@ export function createSummarizer(ctx, service, config) {
         .join("");
       const entries = parseSummaryJson(text || assembledText);
       for (const entry of entries) {
-        service.saveWithDedupe({ ...entry, source: `session:${session.id}` });
+        // Provenance: the summarizer runs on a real session (turn/end hook), so
+        // session.id is always available here — it rides both the human-readable
+        // source label and the structured session_id column (v0.5.x memory
+        // provenance, the raw material for v0.6.0 reasoning-path / drift analysis).
+        service.saveWithDedupe({ ...entry, source: `session:${session.id}`, session_id: session.id });
       }
     } finally {
       if (audit) {

package/lib/tools.js

@@ -16,6 +16,7 @@ const MEMORY_ITEM_SCHEMA = {
     tags: { type: "array", items: { type: "string" } },
     importance: { type: "integer", required: true },
     source: { type: "string" },
+    session_id: { type: "string" },
     created_at: { type: "string", required: true },
     updated_at: { type: "string", required: true }
   }
@@ -48,14 +49,18 @@ export function createTools(ctx, service, config, embedder) {
         },
         render: (_args, value) => TEXT_OUTPUT(`memory ${value.action}: ${value.id}`)
       },
-      async execute(args) {
+      async execute(args, exec) {
         const { action, memory } = service.saveWithDedupe({
           type: args.type,
           title: args.title,
           content: args.content,
           tags: args.tags ?? [],
           importance: args.importance ?? 3,
-          source: args.source ?? "tool"
+          source: args.source ?? "tool",
+          // Provenance: the session that issued the tool call. exec.agent is
+          // set by the agent loop (undefined in unit tests / direct calls) —
+          // absent a session, session_id stays null rather than fabricating one.
+          session_id: exec?.agent?.session?.id ?? undefined
         });
         return { action, id: memory.id };
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 7 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/config.js

@@ -19,11 +19,13 @@ export const Config = z.object({
   dreamModel: z.string(),
   dreamMaxTokens: z.natural().min(256).max(131072).default(8192),
   // Pass-through reasoning effort for dream's LLM calls. 'none' (default)
-  // omits the field so the provider's own default applies; low/medium/high
-  // are forwarded verbatim. Useful to cap reasoning spend on thinking-type
-  // models that would otherwise drain the whole token budget and return an
-  // empty body ("no json array in llm output").
+  // omits the field so the provider's own default applies; 'off' explicitly
+  // disables thinking — REQUIRED for thinking-type models (deepseek-v4-flash
+  // etc.) that would otherwise drain the whole token budget into reasoning and
+  // return an empty body ("no json array in llm output"); low/medium/high are
+  // forwarded verbatim to cap reasoning spend.
   dreamReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),
@@ -197,9 +199,11 @@ export const Config = z.object({
   sleepProvider: z.string().default(""),
   sleepModel: z.string().default(""),
   // Pass-through reasoning effort for sleep's LLM passes, same semantics as
-  // dreamReasoningEffort: 'none' (default) omits the field; low/medium/high
-  // are forwarded verbatim.
+  // dreamReasoningEffort: 'none' (default) omits the field; 'off' explicitly
+  // disables thinking (thinking-type models would burn the whole budget on
+  // reasoning); low/medium/high are forwarded verbatim.
   sleepReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),

package/src/dream.js

@@ -1,7 +1,7 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts } from "./dream/clustering.js";
 import { createHash, randomUUID } from "node:crypto";
-export { validateDecisions, applyDecisions };
+export { validateDecisions, applyDecisions, normalizeDecisions };
 
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -40,6 +40,95 @@ function extractJsonArray(text) {
   }
   return null;
 }
+
+/**
+ * Field-name drift guard (v0.5.3): thinking-type models (deepseek-v4-flash
+ * etc.) occasionally ignore the prompt's exact decision schema and emit alias
+ * keys —实测方案 A 输出 "consolidation"/"target_ids"、方案 B 输出
+ * "action"/"targetIds"，都不是插件要求的 "action"/"ids"。normalizeDecisions
+ * 在 validateDecisions 之前把常见变体重写回规范字段名，让"字段名不听话但
+ * 语义正确"的输出仍可被应用，而不是整单被拒。覆盖三类漂移：
+ *   1. 整个 body 是包在对象里的数组（{consolidation:[...]} /
+ *      {decisions:[...]} / {actions:[...]}）；
+ *   2. 决策对象用了别名键（target_ids→ids、keep_source→keepSource、
+ *      winner_id→winner、targetIds→ids 等）；
+ *   3. action 值用了同义词（archived→archive、consolidation→merge 等）。
+ * 无归一化必要时原样返回（null→null，调用方"no json array"分支不受影响）。
+ */
+const FIELD_ALIASES = {
+  // "consolidation" 也可作 action 键（实测 deepseek-v4-flash 这么写过）；
+  // 但 normalizeOne 对 action 键做字符串过滤，{consolidation:[...]} 这种
+  // wrapper 数组不会被误当成 action（顶层 WRAPPER_KEYS 负责解包）。
+  action: ["action", "decision", "operation", "op", "action_type", "actionType", "mode", "consolidation"],
+  // 注意：action 别名不含 "type"——create 决策的 type 是合法的记忆类型字段，
+  // 不能误当 action。
+  ids: ["ids", "target_ids", "targetIds", "targets", "memory_ids", "memoryIds", "id_list", "idList", "memories"],
+  reason: ["reason", "rationale", "why", "comment", "note", "explanation"],
+  importance: ["importance", "priority", "weight", "level", "score"],
+  keepSource: ["keepSource", "keep_source", "source_id", "sourceId", "keeper", "keep_id", "keepId"],
+  winner: ["winner", "winner_id", "winnerId", "win_id", "winId", "preferred", "primary"],
+  loser: ["loser", "loser_id", "loserId", "lose_id", "loseId", "drop_id", "dropId", "archive_id", "archiveId"],
+  title: ["title", "new_title", "newTitle", "merged_title", "mergedTitle", "merge_title", "mergeTitle"],
+  content: ["content", "new_content", "newContent", "merged_content", "mergedContent", "merge_content", "mergeContent"],
+  evidence: ["evidence", "evidence_ids", "evidenceIds"]
+};
+
+// 保守的 action 值同义词：只收语义无歧义、不可能被误认为记忆类型/其他 action 的映射。
+const ACTION_SYNONYMS = {
+  archived: "archive",
+  remove: "archive",
+  delete: "archive",
+  combine: "merge",
+  consolidation: "merge",
+  consolidate: "merge",
+  modify: "update",
+  edit: "update"
+};
+
+const WRAPPER_KEYS = ["consolidation", "decisions", "actions", "results", "updates", "list", "data"];
+
+/** 把单个决策对象重写到规范字段名；非对象原样返回。 */
+function normalizeOne(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const d = {};
+  const consumed = new Set();
+  for (const [canon, aliases] of Object.entries(FIELD_ALIASES)) {
+    for (const key of aliases) {
+      if (key in raw && raw[key] !== undefined && raw[key] !== null) {
+        // action 必须是字符串——{consolidation:[...]} 的 wrapper 数组跳过。
+        if (canon === "action" && Array.isArray(raw[key])) continue;
+        d[canon] = raw[key];
+        consumed.add(key);
+        break;
+      }
+    }
+  }
+  // 保留未被别名消费的原始键（create 的 type、未来字段）原样透传。
+  for (const key of Object.keys(raw)) {
+    if (!consumed.has(key)) d[key] = raw[key];
+  }
+  if (typeof d.action === "string") {
+    const low = d.action.toLowerCase();
+    if (ACTION_SYNONYMS[low] !== undefined) d.action = ACTION_SYNONYMS[low];
+  }
+  // ids 若被写成单个字符串则包成数组（validateDecisions 要求数组）。
+  if (d.ids !== undefined && typeof d.ids === "string") d.ids = [d.ids];
+  return d;
+}
+
+/** 归一化 LLM 决策 body（数组 / 包裹对象 / 单个决策对象），null 原样返回。 */
+function normalizeDecisions(raw) {
+  if (!raw) return raw;
+  if (Array.isArray(raw)) return raw.map(normalizeOne).filter((d) => d && typeof d === "object");
+  if (typeof raw === "object") {
+    for (const key of WRAPPER_KEYS) {
+      if (Array.isArray(raw[key])) return normalizeDecisions(raw[key]);
+    }
+    // 单个决策对象 → 包成单元素数组（validateDecisions 要求数组）。
+    return [normalizeOne(raw)];
+  }
+  return raw;
+}
 const SUMMARY_PROMPT = `你是记忆库摘要助手。根据整理后的记忆，生成一段 150-200 字的记忆库总览，覆盖：用户偏好、活跃项目、关键决策。之后作为会话上下文注入。只输出摘要文本，不要其他内容。`;
 
 const CONSOLIDATION_PROMPT = `你是记忆库整理助手。下面是全部记忆条目（id、类型、标题、内容、重要性、更新时间）。
@@ -616,7 +705,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       return finish({ ok: false, error: "llm failed", summary: false });
     }
 
-    const decisions = extractJsonArray(decisionText);
+    // v0.5.3 字段名归一化兜底：thinking 模型可能输出别名键/wrapper 对象，
+    // 在 validateDecisions 之前重写到规范字段名，语义正确但 schema 不听话的
+    // 输出不再整单被拒。
+    const decisions = normalizeDecisions(extractJsonArray(decisionText));
     if (!Array.isArray(decisions)) {
       logger?.warn?.(`dsh-mneme dream: no json array in llm output (raw length ${decisionText?.length ?? 0})`);
       return finish({ ok: false, error: "no json array in llm output", summary: false });

package/src/service.js

@@ -811,6 +811,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       tags: memory.tags ?? [],
       importance: memory.importance ?? 3,
       source: memory.source ?? "manual",
+      // Provenance (v0.5.x): birth session rides through the create path; the
+      // merge path above preserves the original row's session_id untouched.
+      session_id: memory.session_id ?? undefined,
       ...(quality ? { quality_score: quality.score } : {})
     });
     const result = applyQualityDisposition(created, quality, qf);

package/src/store.js

@@ -12,6 +12,7 @@ CREATE TABLE IF NOT EXISTS memories (
   forgotten   INTEGER NOT NULL DEFAULT 0,
   archived    INTEGER NOT NULL DEFAULT 0,
   source      TEXT,
+  session_id  TEXT,
   content_history TEXT,
   embedding   TEXT,
   epistemic_status TEXT NOT NULL DEFAULT 'subjective',
@@ -321,6 +322,7 @@ function toRow(row) {
     forgotten: row.forgotten === 1,
     archived: row.archived === 1,
     source: row.source ?? undefined,
+    session_id: row.session_id ?? undefined,
     content_history: parseJsonArray(row.content_history),
     quality_score: row.quality_score !== null && row.quality_score !== undefined ? Number(row.quality_score) : undefined,
     epistemic_status: row.epistemic_status ?? "subjective",
@@ -571,6 +573,7 @@ export function createStore(path) {
   addColumn("memories", "epistemic_status", "ALTER TABLE memories ADD COLUMN epistemic_status TEXT NOT NULL DEFAULT 'subjective'");
   addColumn("memories", "content_history", "ALTER TABLE memories ADD COLUMN content_history TEXT");
   addColumn("memories", "quality_score", "ALTER TABLE memories ADD COLUMN quality_score REAL");
+  addColumn("memories", "session_id", "ALTER TABLE memories ADD COLUMN session_id TEXT");
 
   // Legacy dream_runs without policy_epoch → backfill with the default epoch.
   addColumn("dream_runs", "policy_epoch", "ALTER TABLE dream_runs ADD COLUMN policy_epoch INTEGER NOT NULL DEFAULT 0");
@@ -657,8 +660,8 @@ export function createStore(path) {
       : inferEpistemicStatus(memory);
     runAtomically(() => {
       db.prepare(
-        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, content_history, quality_score, embedding, epistemic_status, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, session_id, content_history, quality_score, embedding, epistemic_status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ).run(
         id,
         type,
@@ -668,6 +671,7 @@ export function createStore(path) {
         importance,
         memory.archived ? 1 : 0,
         memory.source ?? null,
+        memory.session_id ?? null,
         JSON.stringify(memory.content_history ?? []),
         Number.isFinite(memory.quality_score) ? memory.quality_score : null,
         embedding,

package/src/summarize.js

@@ -182,7 +182,11 @@ export function createSummarizer(ctx, service, config) {
         .join("");
       const entries = parseSummaryJson(text || assembledText);
       for (const entry of entries) {
-        service.saveWithDedupe({ ...entry, source: `session:${session.id}` });
+        // Provenance: the summarizer runs on a real session (turn/end hook), so
+        // session.id is always available here — it rides both the human-readable
+        // source label and the structured session_id column (v0.5.x memory
+        // provenance, the raw material for v0.6.0 reasoning-path / drift analysis).
+        service.saveWithDedupe({ ...entry, source: `session:${session.id}`, session_id: session.id });
       }
     } finally {
       if (audit) {

package/src/tools.js

@@ -16,6 +16,7 @@ const MEMORY_ITEM_SCHEMA = {
     tags: { type: "array", items: { type: "string" } },
     importance: { type: "integer", required: true },
     source: { type: "string" },
+    session_id: { type: "string" },
     created_at: { type: "string", required: true },
     updated_at: { type: "string", required: true }
   }
@@ -48,14 +49,18 @@ export function createTools(ctx, service, config, embedder) {
         },
         render: (_args, value) => TEXT_OUTPUT(`memory ${value.action}: ${value.id}`)
       },
-      async execute(args) {
+      async execute(args, exec) {
         const { action, memory } = service.saveWithDedupe({
           type: args.type,
           title: args.title,
           content: args.content,
           tags: args.tags ?? [],
           importance: args.importance ?? 3,
-          source: args.source ?? "tool"
+          source: args.source ?? "tool",
+          // Provenance: the session that issued the tool call. exec.agent is
+          // set by the agent loop (undefined in unit tests / direct calls) —
+          // absent a session, session_id stays null rather than fabricating one.
+          session_id: exec?.agent?.session?.id ?? undefined
         });
         return { action, id: memory.id };
       }

package/test/normalize-decisions.test.js

@@ -0,0 +1,120 @@
+// Field-name normalization guard (v0.5.3): thinking-type models
+// (deepseek-v4-flash etc.) sometimes ignore the prompt's exact decision schema
+// and emit alias keys —实测方案 A 输出 "consolidation"/"target_ids"、方案 B
+// 输出 "action"/"targetIds"，都不是插件要求的 "action"/"ids"。normalizeDecisions
+// 在 validateDecisions 之前把这些变体重写回规范字段名，让"语义正确但 schema
+// 不听话"的输出仍被应用，而不是整单被拒。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { normalizeDecisions, createDreamScheduler } from "../src/dream.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+test("normalizeDecisions: canonical decisions pass through untouched", () => {
+  const raw = [
+    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c", importance: 4, reason: "主题相近" },
+    { action: "conflict", winner: "m3", loser: "m4", reason: "矛盾" },
+    { action: "update", ids: ["m5"], content: "修正" },
+    { action: "archive", ids: ["m6"], reason: "过时" },
+    { action: "create", type: "pattern", title: "新模式", content: "发现", importance: 3 }
+  ];
+  assert.deepEqual(normalizeDecisions(raw), raw);
+});
+
+test("normalizeDecisions: alias keys rewritten to canonical names", () => {
+  const raw = [
+    { consolidation: "merge", target_ids: ["m1", "m2"], keep_source: "m1", new_title: "t", new_content: "c", priority: 4, rationale: "主题相近" },
+    { action: "conflict", winner_id: "m3", loser_id: "m4", why: "矛盾" },
+    { action: "update", targetIds: ["m5"], merged_content: "修正" },
+    { action: "archive", memory_ids: ["m6"] }
+  ];
+  assert.deepEqual(normalizeDecisions(raw), [
+    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c", importance: 4, reason: "主题相近" },
+    { action: "conflict", winner: "m3", loser: "m4", reason: "矛盾" },
+    { action: "update", ids: ["m5"], content: "修正" },
+    { action: "archive", ids: ["m6"] }
+  ]);
+});
+
+test("normalizeDecisions: action value synonyms normalized", () => {
+  const raw = [
+    { action: "archived", ids: ["m1"], reason: "重复" },
+    { action: "consolidation", target_ids: ["m2", "m3"], keep_source: "m2" },
+    { action: "combine", targetIds: ["m4", "m5"], keeper: "m5" },
+    { action: "Remove", memory_ids: ["m6"] }
+  ];
+  const normalized = normalizeDecisions(raw);
+  assert.equal(normalized[0].action, "archive");
+  assert.equal(normalized[1].action, "merge");
+  assert.equal(normalized[1].ids[0], "m2");
+  assert.equal(normalized[2].action, "merge");
+  assert.equal(normalized[2].keepSource, "m5");
+  assert.equal(normalized[3].action, "archive");
+});
+
+test("normalizeDecisions: wrapper object around the array is unwrapped", () => {
+  const raw = { consolidation: [{ action: "merge", ids: ["m1"], keepSource: "m1", title: "t", content: "c" }] };
+  assert.deepEqual(normalizeDecisions(raw), [
+    { action: "merge", ids: ["m1"], keepSource: "m1", title: "t", content: "c" }
+  ]);
+  const raw2 = { decisions: [{ action: "archive", target_ids: ["m9"] }] };
+  assert.deepEqual(normalizeDecisions(raw2), [{ action: "archive", ids: ["m9"] }]);
+});
+
+test("normalizeDecisions: single decision object (non-array) normalized too", () => {
+  const raw = { action: "update", targetIds: ["m1"], new_content: "修正" };
+  assert.deepEqual(normalizeDecisions(raw), [{ action: "update", ids: ["m1"], content: "修正" }]);
+});
+
+test("normalizeDecisions: single-string ids become a one-element array", () => {
+  const raw = [{ action: "archive", target_id: "m7" }];
+  // target_id (singular) is not an alias key — the raw key survives untouched
+  // and validateDecisions rejects it (safe side). But targetIds (plural, string)
+  // IS mapped and wrapped.
+  const raw2 = [{ action: "archive", targetIds: "m7" }];
+  assert.deepEqual(normalizeDecisions(raw2), [{ action: "archive", ids: ["m7"] }]);
+  assert.deepEqual(normalizeDecisions(raw), [{ action: "archive", target_id: "m7" }]);
+});
+
+test("normalizeDecisions: create keeps its type field (never mistaken for action)", () => {
+  const raw = { action: "create", type: "preference", title: "语言", content: "中文", importance: 3 };
+  assert.deepEqual(normalizeDecisions(raw), [
+    { action: "create", type: "preference", title: "语言", content: "中文", importance: 3 }
+  ]);
+});
+
+test("normalizeDecisions: null / non-parseable returns as-is (caller's no-json branch)", () => {
+  assert.equal(normalizeDecisions(null), null);
+  assert.equal(normalizeDecisions(undefined), undefined);
+  assert.equal(normalizeDecisions("not json"), "not json");
+});
+
+test("dream runDream applies alias-key consolidation output end-to-end", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const ctx = {
+    logger: { warn: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          // deepseek-v4-flash 实测风格：consolidation 当 action、target_ids 当 ids
+          yield { type: "text-delta", index: 0, text: JSON.stringify([
+            { consolidation: "merge", target_ids: [a.id, b.id], keep_source: b.id, new_title: "插件总览", new_content: "合并内容", priority: 4 }
+          ]) };
+        } else {
+          yield { type: "text-delta", index: 0, text: "记忆库总览：默认摘要。" };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, true, "alias-key output must not be rejected wholesale");
+  assert.ok(result.applied > 0, "alias-key decisions still land changes");
+  store.close();
+});

package/test/provenance.test.js

@@ -0,0 +1,103 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { DatabaseSync } from "node:sqlite";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+
+const openMemory = () => createStore(":memory:");
+
+// Memory provenance (v0.5.x): every memory born from a session carries its
+// session_id so v0.6.0 reasoning-path / interest-drift analysis can rebuild
+// the derivation chain later. session_id is birth provenance — set once at
+// creation, preserved by merges, never fabricated when no session exists.
+
+test("save persists session_id and returns it", () => {
+  const store = openMemory();
+  const saved = store.save({
+    type: "preference",
+    title: "A",
+    content: "c",
+    tags: [],
+    importance: 3,
+    source: "tool",
+    session_id: "session-42"
+  });
+  assert.equal(saved.session_id, "session-42");
+  assert.equal(store.getById(saved.id).session_id, "session-42");
+  store.close();
+});
+
+test("save without session_id leaves it undefined (never fabricated)", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "history", title: "B", content: "c" });
+  assert.equal(saved.session_id, undefined);
+  store.close();
+});
+
+test("dedupe merge keeps the ORIGINAL session_id (provenance = birth)", () => {
+  const store = openMemory();
+  const service = createService({ store, mirror: null, config: {} });
+  service.saveWithDedupe({
+    type: "preference", title: "语言", content: "中文", session_id: "session-1"
+  });
+  const merged = service.saveWithDedupe({
+    type: "preference", title: "语言", content: "中文 + 英文", session_id: "session-2"
+  });
+  assert.equal(merged.action, "merged");
+  assert.equal(store.getById(merged.memory.id).session_id, "session-1");
+  store.close();
+});
+
+test("memory_save tool records exec.agent.session.id as session_id", async () => {
+  const store = openMemory();
+  const service = createService({ store, mirror: null, config: {} });
+  const ctx = { tools: { register() { return () => {}; } } };
+  const tools = createTools(ctx, service, {}, undefined);
+  const saveTool = tools.find((t) => t.name === "memory_save");
+  const out = await saveTool.execute(
+    { type: "decision", title: "T", content: "c" },
+    { agent: { session: { id: "session-tool-9" } } }
+  );
+  assert.equal(store.getById(out.id).session_id, "session-tool-9");
+  store.close();
+});
+
+test("memory_save tool without agent context leaves session_id null", async () => {
+  const store = openMemory();
+  const service = createService({ store, mirror: null, config: {} });
+  const ctx = { tools: { register() { return () => {}; } } };
+  const tools = createTools(ctx, service, {}, undefined);
+  const saveTool = tools.find((t) => t.name === "memory_save");
+  const out = await saveTool.execute({ type: "decision", title: "T2", content: "c" }, {});
+  assert.equal(store.getById(out.id).session_id, undefined);
+  store.close();
+});
+
+test("legacy DB without session_id column migrates and saves with provenance", () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-prov-"));
+  const dbPath = join(dir, "legacy.db");
+  const db = new DatabaseSync(dbPath);
+  db.exec(`CREATE TABLE memories (
+    id TEXT PRIMARY KEY, type TEXT NOT NULL, title TEXT NOT NULL, content TEXT NOT NULL,
+    tags TEXT NOT NULL DEFAULT '[]', importance INTEGER NOT NULL DEFAULT 3,
+    forgotten INTEGER NOT NULL DEFAULT 0, archived INTEGER NOT NULL DEFAULT 0,
+    source TEXT, content_history TEXT, embedding TEXT,
+    epistemic_status TEXT NOT NULL DEFAULT 'subjective',
+    last_accessed_at TEXT, _full_content TEXT,
+    created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+  );`);
+  db.close();
+  const store = createStore(dbPath);
+  const cols = store.db.prepare("PRAGMA table_info(memories)").all().map((c) => c.name);
+  assert.ok(cols.includes("session_id"), "session_id column added by migration");
+  const saved = store.save({
+    type: "history", title: "旧库", content: "迁移后仍可溯源", session_id: "session-legacy"
+  });
+  assert.equal(store.getById(saved.id).session_id, "session-legacy");
+  store.close();
+  rmSync(dir, { recursive: true, force: true });
+});

package/test/reasoning-effort.test.js

@@ -36,6 +36,11 @@ test("issue#9: reasoningEffort config defaults to none and rejects unknown value
   assert.equal(cfg.sleepReasoningEffort, "none");
   assert.equal(Config({ dreamReasoningEffort: "high" }).dreamReasoningEffort, "high");
   assert.equal(Config({ sleepReasoningEffort: "medium" }).sleepReasoningEffort, "medium");
+  // v0.5.3: 'off' explicitly disables thinking — required for thinking-type
+  // models (deepseek-v4-flash) whose reasoning otherwise drains the whole
+  // token budget and returns an empty consolidation body.
+  assert.equal(Config({ dreamReasoningEffort: "off" }).dreamReasoningEffort, "off");
+  assert.equal(Config({ sleepReasoningEffort: "off" }).sleepReasoningEffort, "off");
   assert.throws(() => Config({ dreamReasoningEffort: "bogus" }), "invalid effort rejected");
   assert.throws(() => Config({ sleepReasoningEffort: "ultra" }), "invalid effort rejected");
 });
@@ -107,6 +112,28 @@ test("issue#9: dream forwards dreamReasoningEffort on both LLM calls", async ()
   store.close();
 });
 
+test("issue#9: dream forwards dreamReasoningEffort:off (thinking disabled) on both LLM calls", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const captured = [];
+  const ctx = dreamCtx({
+    captured,
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "插件总览", content: "合并内容", importance: 4 }
+    ])
+  });
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "off" });
+  assert.equal(result.ok, true);
+  assert.equal(captured.length, 2);
+  for (const options of captured) {
+    assert.equal(options.reasoningEffort, "off", `reasoningEffort:"off" forwarded on ${options.purpose}`);
+  }
+  store.close();
+});
+
 // ---------------------------------------------------------------- sleep passthrough
 
 function sleepSetup() {