sage-mem 0.5.2 → 0.5.4

package/README.md

@@ -4,6 +4,10 @@
 
 记忆存在**本地 markdown 文件**里（frontmatter + 正文），不是数据库。透明、可检查、防膨胀。
 
+> **DSH 版本兼容性（0.5.3 核对于 `0.1.7-rc.1`）**
+> `session.deriveMessages()`（仍是同步）、`system-prompt/assemble` 事件、以及 `context.agent.session` 这条链，在 0.1.6 → 0.1.7 之间**均未改变**，本插件在 0.1.7 上无需改动即可工作。
+> 0.5.3 另加了一层防御：`deriveMessages()` 若哪天被改成异步，或 `Session` 上的历史读取接口被改名（0.1.7 起 `snapshotEvents` / `eventAt` / `ownEvents` 已标记弃用），插件会在**日志里报警**，而不是像以前那样静默地不再注入记忆。0.1.6 上的行为与 0.5.2 完全一致。
+
 ## 从 Claude Code 无损迁移
 
 你已经在 Claude Code（CC）里养了一个 agent，舍不得它的记忆和人格？sage-mem 是「CC → DSH」迁移方案的一部分，**记忆与人格都能无损搬过来**：

package/lib/client.js

@@ -1478,6 +1478,176 @@ const StarmapRuntime = (function (require, _react) {
 		};
 		const TYPE_ORDER = ["user", "feedback", "project", "reference"];
 
+		// ── frontmatter 纯逻辑（顶层自包含普通函数，不碰 React state）─────
+		//
+		// 2026-09-25 P0 数据事故的根因全在这几行里，三条硬规矩：
+		//   1) 绝不「重建」frontmatter —— 就地合并，除 description / type 外每一行
+		//      逐字保留。旧版 buildFrontmatter() 只写 name/description/type 三个字段，
+		//      保存一次就把 baseline / node_type / originSessionId / updated 全抹掉
+		//      （baseline 一丢，「每次会话必读」的记忆从此不再注入）。
+		//   2) 类型正则必须锚行首：`  node_type: memory` 里的 `type:` 否则会被先命中，
+		//      捕获到 memory → 不在 TYPE_ORDER 里 → 兜底成 reference（全库 45 条中招）。
+		//   3) 换行必须容忍 CRLF（Windows 编辑器碰一次就是 \r\n）；回写沿用原文件的
+		//      换行风格，从而 LF / CRLF 都能逐字节 round-trip。
+
+		/** 去掉值两侧成对的引号（与 host 半 parseFrontmatter 的剥法一致）。 */
+		function stripQuotes(v) {
+			const s = typeof v === "string" ? v.trim() : "";
+			return s.replace(/^["']|["']$/g, "").trim();
+		}
+
+		/** 渲染成双引号 YAML 标量：转义反斜杠与双引号（旧版把 " 换成 ' 会改字）。 */
+		function yamlQuote(v) {
+			return String(v == null ? "" : v).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+		}
+
+		/** 传整篇 content 或只传 fm 文本都能用；以 --- 开头的当整篇拆。 */
+		function fmInner(text) {
+			const t = typeof text === "string" ? text : "";
+			return /^---[ \t]*\r?\n/.test(t) ? splitFrontmatter(t).fm : t;
+		}
+
+		/**
+		 * 拆 frontmatter。返回 { hasFm, fm, body }：
+		 *   fm   = 两条 --- 之间的原始文本（不含定界行）
+		 *   body = 定界之后的内容（只吃掉紧跟 --- 的那一个换行，其余原样）
+		 * 没有 frontmatter 时 hasFm=false、fm=""、body=整个 content。
+		 */
+		function splitFrontmatter(content) {
+			const text = typeof content === "string" ? content : "";
+			const m = text.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n)?/);
+			if (!m) return { hasFm: false, fm: "", body: text };
+			return { hasFm: true, fm: m[1], body: text.slice(m[0].length) };
+		}
+
+		/**
+		 * 识别记忆类型。锚行首（^ + m），**不看 node_type**：
+		 *   1) 顶层 `type: X`
+		 *   2) metadata 块内的缩进写法 `  type: X`
+		 * 优先级与 host 半 parseFrontmatter 一致（顶层优先）。找不到返回 ""。
+		 */
+		function detectType(text) {
+			const fm = fmInner(text);
+			const top = fm.match(/^type[ \t]*:[ \t]*([^\r\n]*)/m);
+			if (top) return stripQuotes(top[1]);
+			const nested = fm.match(/^[ \t]+type[ \t]*:[ \t]*([^\r\n]*)/m);
+			if (nested) return stripQuotes(nested[1]);
+			return "";
+		}
+
+		/**
+		 * 兜底：读 node_type。本机有两份老文件没有 type 行，node_type 直接就是类型
+		 * （project_ui-lab.md → project、user_courses-2026fall.md → user）。
+		 * 只由调用方在 detectType 返回空时使用 —— detectType 本身绝不认 node_type。
+		 */
+		function detectNodeType(text) {
+			const fm = fmInner(text);
+			const m = fm.match(/^[ \t]*node_type[ \t]*:[ \t]*([^\r\n]*)/m);
+			return m ? stripQuotes(m[1]) : "";
+		}
+
+		/** 取顶层 description 的值（剥掉成对引号）。 */
+		function extractDescription(text) {
+			const fm = fmInner(text);
+			const m = fm.match(/^description[ \t]*:[ \t]*([^\r\n]*)/m);
+			return m ? stripQuotes(m[1]) : "";
+		}
+
+		/**
+		 * 就地合并 frontmatter，返回新的完整文件内容。
+		 * patch = { type, description, addMissingType }
+		 *   - description：与原文相同时整行逐字保留；不同时改写该行；原本没有该行才补一行。
+		 *   - type：只改写已有的 type 行（顶层优先，其次 metadata 内缩进那一行）并保留原缩进；
+		 *     原本没有 type 行时默认一行都不加（不动 node_type-only 的老文件），
+		 *     只有 patch.addMissingType === true 才插入（插进 metadata 块或顶层）。
+		 *   - 其余所有行（name / baseline / node_type / originSessionId / updated / 任意键）
+		 *     逐字保留，顺序不变。
+		 * 没有 frontmatter 的文件原样返回（新增文件走 buildFrontmatter）。
+		 */
+		function mergeFrontmatter(content, patch) {
+			const src = typeof content === "string" ? content : "";
+			const p = patch || {};
+			const parts = splitFrontmatter(src);
+			if (!parts.hasFm) return src;
+
+			const oldDesc = extractDescription(parts.fm);
+			const oldType = detectType(parts.fm);
+			const srcLines = parts.fm.split(/\r?\n/);
+
+			// 目标 type 行的下标：与 detectType 同一优先级（顶层 → 缩进）
+			let typeIdx = -1;
+			for (let i = 0; i < srcLines.length; i++) {
+				if (/^type[ \t]*:/.test(srcLines[i])) { typeIdx = i; break; }
+			}
+			if (typeIdx < 0) {
+				for (let i = 0; i < srcLines.length; i++) {
+					if (/^[ \t]+type[ \t]*:/.test(srcLines[i])) { typeIdx = i; break; }
+				}
+			}
+
+			const wantDesc = typeof p.description === "string" && p.description !== oldDesc;
+			const wantType = typeof p.type === "string" && p.type !== "" && p.type !== oldType;
+			const out = [];
+			let descDone = !wantDesc;
+			let typeDone = !wantType || typeIdx < 0;
+			let metadataAt = -1;
+			for (let i = 0; i < srcLines.length; i++) {
+				const line = srcLines[i];
+				if (/^metadata[ \t]*:/.test(line)) metadataAt = out.length;
+				if (!descDone && /^description[ \t]*:/.test(line)) {
+					out.push('description: "' + yamlQuote(p.description) + '"');
+					descDone = true;
+					continue;
+				}
+				if (!typeDone && i === typeIdx) {
+					out.push((line.match(/^[ \t]*/) || [""])[0] + "type: " + p.type);
+					typeDone = true;
+					continue;
+				}
+				out.push(line);
+			}
+			// 原本没有 type 行 → 仅在调用方明确要求时插入
+			if (typeIdx < 0 && p.addMissingType === true) {
+				if (metadataAt >= 0) {
+					let at = metadataAt + 1;
+					let indent = "  ";
+					for (let i = metadataAt + 1; i < out.length; i++) {
+						const mm = out[i].match(/^([ \t]+)\S/);
+						if (!mm) break;
+						indent = mm[1];
+						at = i + 1;
+					}
+					out.splice(at, 0, indent + "type: " + p.type);
+				} else {
+					out.push("type: " + p.type);
+				}
+			}
+			// 原本没有 description 行 → 补一行（description 本就在可改范围内）
+			if (!descDone) {
+				const rendered = 'description: "' + yamlQuote(p.description) + '"';
+				let at = -1;
+				for (let i = 0; i < out.length; i++) {
+					if (/^name[ \t]*:/.test(out[i])) { at = i + 1; break; }
+				}
+				if (at >= 0) out.splice(at, 0, rendered); else out.unshift(rendered);
+			}
+
+			// 原文件是 CRLF 就照样回写 CRLF（LF 文件回写 \n）——保证逐字节 round-trip。
+			// 组件把原文重建成 "---\n" + fm + "\n---\n" + body，所以还要从 fm / body 里看 CRLF。
+			const eol = /^---[ \t]*\r\n/.test(src) || parts.fm.indexOf("\r\n") >= 0 || parts.body.indexOf("\r\n") >= 0 ? "\r\n" : "\n";
+			return "---" + eol + out.join(eol) + eol + "---" + eol + parts.body;
+		}
+
+		/**
+		 * 新建记忆的 frontmatter（只用于「添加记忆」或原本没有 frontmatter 的文件；
+		 * 编辑已有文件一律走 mergeFrontmatter，绝不重建）。
+		 */
+		function buildFrontmatter(type, desc, fileName) {
+			const slug = String(fileName == null ? "" : fileName).replace(/\.md$/i, "");
+			return "---\nname: \"" + yamlQuote(slug) + "\"\ndescription: \"" + yamlQuote(desc) +
+				"\"\nmetadata:\n  node_type: memory\n  type: " + type + "\n---\n\n";
+		}
+
 		function fmtSize(n) {
 			if (n < 1024) return n + " B";
 			if (n < 1024 * 1024) return (n / 1024).toFixed(1) + " KB";
@@ -1559,6 +1729,12 @@ const StarmapRuntime = (function (require, _react) {
 			const formDesc = sFormDesc[0], setFormDesc = sFormDesc[1];
 			const sFormBody = react.useState("");
 			const formBody = sFormBody[0], setFormBody = sFormBody[1];
+			// 打开编辑时的原 frontmatter 原文（null = 该文件没有 frontmatter）
+			const sFormFm = react.useState(null);
+			const formFm = sFormFm[0], setFormFm = sFormFm[1];
+			// 打开时展示给用户的类型（判断他是否真的改过类型）
+			const sFormBaseType = react.useState("");
+			const formBaseType = sFormBaseType[0], setFormBaseType = sFormBaseType[1];
 			const sBusy = react.useState(false);
 			const busy = sBusy[0], setBusy = sBusy[1];
 			const sOk = react.useState(false);
@@ -1588,6 +1764,7 @@ const StarmapRuntime = (function (require, _react) {
 
 			function closeForm() {
 				setFormOpen(false); setEditingFile(null); setFormName(""); setFormDesc(""); setFormBody(""); setFormType("feedback");
+				setFormFm(null); setFormBaseType("");
 			}
 
 			function openEdit(file) {
@@ -1597,22 +1774,20 @@ const StarmapRuntime = (function (require, _react) {
 					.then(function (res) {
 						const data = unwrap(res);
 						const content = (data && data.content) || "";
-						const fm = content.match(/^---\n([\s\S]*?)\n---\n?/);
-						let type = "reference";
-						let desc = "";
-						let body = content;
-						if (fm) {
-							body = content.slice(fm[0].length);
-							const t = fm[1].match(/type:\s*(\S+)/);
-							if (t) type = t[1];
-							const d = fm[1].match(/description:\s*"?(.+?)"?\n/);
-							if (d) desc = d[1].replace(/["']/g, "");
-						}
+						// 解析走顶层纯函数：拆 frontmatter / 认类型 / 取描述
+						const parts = splitFrontmatter(content);
+						// detectType 只认 type 行（锚行首，不碰 node_type）；
+						// 老文件里 node_type 直接就是类型的，才退回 detectNodeType。
+						const found = detectType(parts.fm) || detectNodeType(parts.fm);
+						const shown = TYPE_ORDER.indexOf(found) >= 0 ? found : "reference";
 						setEditingFile(file);
 						setFormName(file);
-						setFormType(TYPE_ORDER.indexOf(type) >= 0 ? type : "reference");
-						setFormDesc(desc);
-						setFormBody(body);
+						setFormType(shown);
+						setFormBaseType(shown);
+						setFormDesc(extractDescription(parts.fm));
+						setFormBody(parts.body);
+						// 关键：原 frontmatter 原文留着，保存时「就地合并」而不是重建
+						setFormFm(parts.hasFm ? parts.fm : null);
 						setFormOpen(true);
 					})
 					.catch(function (e) { setError(String((e && e.message) || e)); })
@@ -1624,22 +1799,34 @@ const StarmapRuntime = (function (require, _react) {
 				setEditingFile(null);
 				setFormName("");
 				setFormType("feedback");
+				setFormBaseType("feedback");
 				setFormDesc("");
 				setFormBody("");
+				setFormFm(null);
 				setFormOpen(true);
 			}
 
-			function buildFrontmatter(type, desc) {
-				return "---\nname: \"\"\ndescription: \"" + desc.replace(/"/g, "'") + "\"\nmetadata:\n  type: " + type + "\n---\n\n";
-			}
-
 			function submit() {
 				if (!formDesc.trim()) { setError("描述不能为空"); return; }
 				setBusy(true); setError(null); setNotice("");
 				const type = formType;
 				const name = (formName.trim() || (type + "_note.md"));
 				const safeName = name.endsWith(".md") ? name : name + ".md";
-				const content = buildFrontmatter(type, formDesc.trim()) + formBody;
+				const desc = formDesc.trim();
+				let content;
+				if (formFm === null) {
+					// 没有 frontmatter（新增记忆 / 索引文件）→ 生成一份
+					content = buildFrontmatter(type, desc, safeName) + formBody;
+				} else {
+					// 有 frontmatter → 就地合并：除 description / type 外一字不动
+					const original = "---\n" + formFm + "\n---\n" + formBody;
+					content = mergeFrontmatter(original, {
+						type: type,
+						description: desc,
+						// 原文没有 type 行时，只有用户确实改过类型才补写一行
+						addMissingType: type !== formBaseType,
+					});
+				}
 				remote.writeFile(safeName, content)
 					.then(function (r) {
 						// host 侧对保留名 / 非字符串内容 / 超限一律返回 { ok: false, error }，不再抛异常。

package/lib/index.js

@@ -36,17 +36,34 @@ const MAX_BASELINE = 5
  *      frontmatter 里的 originSessionId / birthday 等字段一并抹掉。
  *
  * 判定依据是「丢了能不能从别处重建」：memory 目录**不在任何版本控制下**
- * （在 E:\shengdian 下 `git rev-parse` 直接报 not a git repository），
+ * （该目录里没有 .git，`git rev-parse` 直接报 not a git repository），
  * deleteFile 是 unlink、没有回收站，所以宁严勿松。
  * 这几个文件要改，用文件工具直接编辑。
+ *
+ * ⚠️ 全部小写存放，比较一律走 nameKey()（NTFS 不区分大小写，集合里放 'MEMORY.md'
+ * 而拿 'memory.md' 去 has() 是查不到的 —— 曾经就是这个漏洞：表单里填 memory.md
+ * 就能整份覆盖 19 KB 的索引，deleteFile 还能不可逆删掉它）。
  */
 const RESERVED_FILES = new Set([
-  'MEMORY.md',
+  'memory.md',
   'session-log.md',
   'project_heartscape.md',
   'project_self-cognition.md',
 ])
 
+/**
+ * 非记忆条目：不参与检索 / 不进星图 / 不出现在设置页列表里，读写也一律不通。
+ *
+ * 是 RESERVED_FILES 的子集，区别在「列不列出来」：MEMORY.md 是索引、
+ * session-log.md 是追加型流水（已 390+ KB），两者都不是一条记忆；
+ * 而 project_heartscape.md / project_self-cognition.md 是正常记忆条目
+ * （要出现在列表与星图里、要能读），只是不许从表单写/删。
+ */
+const NON_ENTRY_FILES = new Set([
+  'memory.md',
+  'session-log.md',
+])
+
 /**
  * 单文件体积上限（字节）。定 512 KB 的理由：
  *   - 当前 memory 目录最大的一条正文 19 KB（project_guikit.md），索引与流水都排除在外，
@@ -104,7 +121,7 @@ async function scanMemoryFiles(ctx, sessionId) {
   try {
     const entries = await readdir(MEMORY_DIR, { withFileTypes: true })
     const names = entries
-      .filter(e => e.isFile() && e.name.endsWith('.md') && e.name !== 'MEMORY.md' && e.name !== 'session-log.md')
+      .filter(e => e.isFile() && isMemoryEntry(e.name))
       .map(e => e.name)
     const loaded = await Promise.all(names.map(async (name) => {
       try {
@@ -203,11 +220,52 @@ async function writeFileAtomic(target, content) {
   }
 }
 
-/** 防路径穿越：只取 basename，且必须在 memory 目录内（.md，排除索引）。 */
+/**
+ * 文件名归一：只取单段文件名再小写。
+ *
+ * 这是**唯一**的名字比较基准（保留名、非条目名、扫描过滤全走它）。
+ * 不能直接用原始字符串比：NTFS 不区分大小写，`memory.md` 与 `MEMORY.md`
+ * 是同一个文件；`basename` 还顺手挡掉 `..\..\MEMORY.md` 这类带目录成分的输入。
+ */
+function nameKey(raw) {
+  return basename(String(raw ?? '')).toLowerCase()
+}
+
+/** 是否是保留名（写/删一律拒绝）。大小写不敏感。 */
+function isReserved(raw) {
+  return RESERVED_FILES.has(nameKey(raw))
+}
+
+/** 是否是非记忆条目（索引与流水）：列出/检索/星图/读写全部排除。大小写不敏感。 */
+function isNonEntry(raw) {
+  return NON_ENTRY_FILES.has(nameKey(raw))
+}
+
+/** 目录扫描过滤：这个名字算不算一条记忆条目。 */
+function isMemoryEntry(name) {
+  return /\.md$/i.test(String(name ?? '')) && !isNonEntry(name)
+}
+
+/**
+ * 唯一的路径校验函数（防穿越 + 扩展名 + 排除非记忆条目）。
+ *
+ * MemoryGateway.readFile / StarmapGateway.readFile 都走这里，不再各写一套
+ * —— 旧版 starmap 那套内联校验只排除了 'MEMORY.md'（大小写敏感）且**完全不排除
+ * session-log.md**，于是 `starmap.readFile('session-log.md')` 能把 390+ KB 的流水
+ * 整个拉进浏览器。
+ *
+ * 不复用 nameKey 的原因：这里要保留磁盘上的原始大小写（返回值直接 join 进路径）。
+ * @param raw — 调用方传来的文件名（任意值）
+ * @returns 通过校验的原始文件名；非法返回 null
+ */
 function safeName(raw) {
-  const name = basename(String(raw || ''))
-  if (!name || !name.endsWith('.md') || name === 'MEMORY.md') return null
-  return name
+  if (typeof raw !== 'string' || raw === '') return null
+  // basename 与原文不一致＝含目录成分。旧版是「悄悄取 basename 继续」，
+  // 与 starmap 那套（要求 safe === raw）行为不一致；现在统一为拒绝。
+  if (basename(raw) !== raw) return null
+  if (!/\.md$/i.test(raw)) return null
+  if (isNonEntry(raw)) return null
+  return raw
 }
 
 /**
@@ -236,6 +294,16 @@ export class MemoryGateway extends TypertRemoteService {
     // 一条 context 消息——不去重的话同一份记忆会被反复追加，撑爆上下文。
     const recallCache = new Map()
 
+    // 「本会话是否已注入过 baseline」——会话级状态，按 session id 记。
+    //
+    // 为什么不是消息条数：见下面 baseline 那段注释（恢复会话的历史消息早就在
+    // session 里，条数永不为 0）。会话 id 在整场会话里稳定，与 assemble 时
+    // 当前用户消息有没有落盘完全无关，所以新会话、恢复会话两种时序都成立。
+    // 容量 64 与 recallCache 同理，只防长驻进程无限增长：要挤掉一个 id 得先有
+    // 63 场别的会话开起来，那场老会话再被唤醒时最多是把同样的 baseline 再注入一次。
+    const BASELINE_CACHE_MAX = 64
+    const baselineInjected = new Set()
+
     // 按问题检索注入：system-prompt/assemble 是异步 waterfall，监听器可 await。
     // 从 agent.session 拿当前 user message，扫 memory 目录按摘要匹配选相关
     // 文件，读全文作为动态 context 段注入——让 agent 第一轮就「想起」。
@@ -246,8 +314,17 @@ export class MemoryGateway extends TypertRemoteService {
       try {
         const agent = context?.agent
         const session = agent?.session
-        if (!session || typeof session.deriveMessages !== 'function') return assembled
-        const messages = [...session.deriveMessages()]
+        if (!session) return assembled
+        // DSH 0.1.7 起 Session 的历史读取接口在陆续调整（snapshotEvents / eventAt /
+        // ownEvents 已弃用）。deriveMessages 在 0.1.7-rc.1 实测仍在且仍同步，但这三行
+        // 不是白写的：方法一旦被改名或改成异步，老写法要么静默不注入、要么把 Promise
+        // 当数组展开成空。宁可日志里响一声，也不要"记忆不注入但日志一字没有"。
+        if (typeof session.deriveMessages !== 'function') {
+          warnLog(ctx, 'session.deriveMessages() 不可用 —— 记忆召回已跳过（DSH session API 变了？）', sessionId)
+          return assembled
+        }
+        const derived = session.deriveMessages()
+        const messages = [...(derived && typeof derived.then === 'function' ? await derived : derived)]
 
         // 关键：DSH 0.1.5 把工具结果（source.kind === 'tool'）和注入内容
         // （source.kind === 'plugin'）也存成 role: 'user' 的消息。只按 role 取
@@ -265,25 +342,54 @@ export class MemoryGateway extends TypertRemoteService {
           picked.push(f)
         }
 
-        // 新会话首步：注入 frontmatter 标了 `baseline: true` 的记忆。当前这条
-        // 用户消息在 assemble 时还没写进 session，所以首步这里恰好是 0 条。
-        // 这一层补「开场白失忆」——「继续吧」这类短话在 description 里找不到
-        // 匹配，纯检索会返回 0 条，而那恰恰是最需要上下文的时刻。
-        if (userMessages.length === 0) {
+        // baseline：每个会话注入一次，**不看消息条数**。
+        //
+        // 旧写法 `if (userMessages.length === 0)` 依赖一个真实存在的时序：assemble
+        // 触发时当前这条用户消息还没写进 session。已在 DSH 检出里核实为真 ——
+        //   dsh-agent-loop/lib/index.js:906  const claimed = this.inbox.claim(...)   // 只从 pending 队列取走
+        //   dsh-agent-loop/lib/index.js:907  await this.loopCtx.systemPrompt.assemble(...)  // ← 本监听器在这里跑
+        //   dsh-agent-loop/lib/index.js:1046 this.session.append("user/message", ...)  // 落 session 在 preStep 之后
+        // 所以全新会话首步 pick 到 0 条 user message，分支命中。
+        //
+        // 但**恢复 / 续聊会话**的历史消息早就在 session 里，条数永远 ≥ 1 → 分支永不
+        // 命中 → 永不注入。而「继续吧」这类短问题在 description 里找不到匹配、检索
+        // 返回 0 条，baseline 恰恰是那时唯一的兜底。这是本会话级状态要修的东西。
+        let baselineTaken = 0
+        const baselineKey = session.id ? session.id : session
+        if (!baselineInjected.has(baselineKey)) {
           files
             .filter(f => f.baseline)
             .sort((a, b) => a.file.localeCompare(b.file))
             .slice(0, MAX_BASELINE)
-            .forEach(take)
+            .forEach(f => {
+              const before = picked.length
+              take(f)
+              if (picked.length > before) baselineTaken++
+            })
+          // 只有真取到才落标记：首步若正好撞上目录读不到（scanMemoryFiles 降级返回 []），
+          // 整场会话就再也没机会补 baseline 了。宁可下一步重算一次。
+          if (baselineTaken > 0) {
+            baselineInjected.add(baselineKey)
+            if (baselineInjected.size > BASELINE_CACHE_MAX) {
+              baselineInjected.delete(baselineInjected.values().next().value)
+            }
+          }
         }
 
-        if (text && text.length >= 2) selectRelevant(text, files).forEach(take)
-        if (picked.length === 0) return assembled
+        // 检索签名只覆盖「检索出来的那批」，baseline 不再掺进这个签名。
+        // 旧版两者共用 signature，首步签名一旦与后续某步相同，baseline 会连坐被吞；
+        // 反过来，旧版把 baseline 文件名也算进签名，会让同一步的检索结果在下一步
+        // 因签名变化而被重复注入。现在 baseline 由会话级标记保证只来一次，
+        // 检索由这份签名保证同一问题不重复追加，两条线互不干扰。
+        const relevant = text && text.length >= 2 ? selectRelevant(text, files) : []
+        const signature = text + '\u0000' + relevant.map(f => f.file).join(',')
+        if (recallCache.get(session.id) !== signature) {
+          recallCache.set(session.id, signature)
+          if (recallCache.size > 8) recallCache.delete(recallCache.keys().next().value)
+          relevant.forEach(take)
+        }
 
-        const signature = text + '\u0000' + picked.map(f => f.file).join(',')
-        if (recallCache.get(session.id) === signature) return assembled
-        recallCache.set(session.id, signature)
-        if (recallCache.size > 8) recallCache.delete(recallCache.keys().next().value)
+        if (picked.length === 0) return assembled
 
         const parts = picked.map(f => {
           const body = f.content.length > MAX_CHARS_PER_FILE
@@ -339,11 +445,14 @@ export class MemoryGateway extends TypertRemoteService {
    * 拒绝一律返回 { ok: false, error }（不是抛异常）——设置页的调用方按 ok 判定。
    */
   async writeFile(name, content) {
+    // 保留名判定放在最前面、且以 nameKey 归一：'memory.md' / 'MEMORY.MD' /
+    // 'Session-Log.md' 在 NTFS 上都是同一个文件，必须一律走 { ok: false } 这条路
+    // （设置页按 ok 判定，见 client.js 的 submit()）。
+    if (isReserved(name)) {
+      return { ok: false, file: nameKey(name), error: `sage-mem: reserved file, edit it with the file tools: ${nameKey(name)}` }
+    }
     const safe = safeName(name)
     if (!safe) throw new Error('sage-mem: invalid file name')
-    if (RESERVED_FILES.has(safe)) {
-      return { ok: false, file: safe, error: `sage-mem: reserved file, edit it with the file tools: ${safe}` }
-    }
     // 不加这一层，传个对象进来会被 String() 写成 "[object Object]" 还回 { ok: true }，
     // 原文件就此被一行垃圾顶掉，且没有任何错误信号。
     if (typeof content !== 'string') {
@@ -357,13 +466,13 @@ export class MemoryGateway extends TypertRemoteService {
     return { ok: true, file: safe }
   }
 
-  /** 删除单个记忆文件：保留名一律拒绝（unlink 不可逆）。 */
+  /** 删除单个记忆文件：保留名一律拒绝（unlink 不可逆）。判定同 writeFile。 */
   async deleteFile(name) {
+    if (isReserved(name)) {
+      return { ok: false, error: `sage-mem: reserved file, refusing to delete: ${nameKey(name)}` }
+    }
     const safe = safeName(name)
     if (!safe) throw new Error('sage-mem: invalid file name')
-    if (RESERVED_FILES.has(safe)) {
-      return { ok: false, error: `sage-mem: reserved file, refusing to delete: ${safe}` }
-    }
     await unlink(join(MEMORY_DIR, safe))
     return { ok: true }
   }
@@ -392,7 +501,7 @@ async function scanStars(ctx) {
     return []
   }
   const names = entries
-    .filter(e => e.isFile() && e.name.endsWith('.md') && e.name !== 'MEMORY.md' && e.name !== 'session-log.md')
+    .filter(e => e.isFile() && isMemoryEntry(e.name))
     .map(e => e.name)
   const loaded = await Promise.all(names.map(async (name) => {
     try {
@@ -434,11 +543,10 @@ export class StarmapGateway extends TypertRemoteService {
   }
 
   async readFile(name) {
-    const raw = String(name || '')
-    const safe = basename(raw)
-    if (!safe || safe !== raw || !safe.endsWith('.md') || safe === 'MEMORY.md') {
-      throw new Error('sage-starmap: invalid file name')
-    }
+    // 与 MemoryGateway.readFile 收敛到同一个 safeName：它现在同时排除
+    // MEMORY.md 与 session-log.md，且大小写不敏感。
+    const safe = safeName(name)
+    if (!safe) throw new Error('sage-starmap: invalid file name')
     const content = await readFile(join(MEMORY_DIR, safe), 'utf8')
     return { name: safe, content }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sage-mem",
   "description": "File-based memory plugin for DeepSeek Harness (DSH) — cross-session memory in transparent markdown files, with a memory star-map view",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -39,7 +39,9 @@
         "0.1.3-alpha.2": "compatible",
         "0.1.5-rc.1": "compatible",
         "0.1.6-alpha.1": "compatible",
-        "0.1.6-alpha.2": "compatible"
+        "0.1.6-alpha.2": "compatible",
+        "0.1.7-rc.1": "compatible",
+        "0.1.7-rc.2": "compatible"
       }
     }
   },