dsh-lite-memory 0.2.7 → 0.2.8

package/README.md

@@ -19,7 +19,7 @@ Lightweight memory for the DeepSeek Harness. Nothing in the system prompt, nothi
 | **L1** 它发现有跨会话价值的经验 | 一行灰字 `memory · keep? "X" — 要记的内容` + 一个 `keep` 按钮；标题加一句话，看得懂才点，不点就永远不写，48 小时内不重复 |
 | **L2** 常识、一次性参数、凭据的值 | 永不写入 |
 
-这些行只属于产生它的那一轮：重进会话就没了，历史里只留正文。同一件事再记一次会合并进原条目，不会长成两条。
+这些行只属于产生它的那一轮：重进会话就没了，历史里只留正文。同一件事再记一次会合并进原条目（旧要点保留，同键的新值覆盖）；前置条件不同的同一主题是两条，不合并。
 
 触发词：`记住`、`记一下`、`上次`、`规范`、`约定`、`路径`、`凭据怎么取`。
 
@@ -29,7 +29,7 @@ Lightweight memory for the DeepSeek Harness. Nothing in the system prompt, nothi
 | **L1** it spots something worth keeping | one muted line `memory · keep? "X" — what would be remembered` with a single `keep` button — readable before you click, nothing written unless you click, at most once per two days |
 | **L2** common sense, one-off parameters, credential values | never written |
 
-Those lines belong to the turn that made them: reopening the session drops them, leaving only the prose in history. Recording the same subject again merges into the existing entry instead of adding a second one.
+Those lines belong to the turn that made them: reopening the session drops them, leaving only the prose in history. Recording the same subject again merges into the existing entry — earlier points are kept and only conflicting keys are updated. The same subject under different preconditions stays two entries.
 
 ## 点一下就存 / One click, no turn
 

package/TRIGGERS.md

@@ -36,12 +36,20 @@
 
 ## 什么时候合并，什么时候新建
 
-一条约束只留一条。写入前先拿标题和摘要比一遍：够近就合并进原条目（`merges+1`），正文整篇替换；不够近才新建。
+一条约束只留一条，但**前置条件不一样就是两条**。同一条记忆挂在「什么情况下」上：换机器、换环境、换前提，内容往往互相矛盾，硬合并等于丢掉其中一种情况。
 
-- 合并：同一件事换措辞、补细节、纠正旧值。标题相邻两字重合 ≥ 0.6，或摘要重合 ≥ 0.75。
-- 新建：同一项目下的另一件事，哪怕标签一样。只共用项目名（「插件市场条目字段」对「插件市场踩坑清单」）不算合并。
-- 合并前先 `memory_read` 旧正文：正文是替换，不是追加，漏读就丢细节。
-- 判不准先 `memory_search`：命中就是同一件事，按命中那条的标题写；没命中再新建。
+判断顺序：
+
+1. 前置条件不同（含一边写了自己没写）→ 新建，标题后面跟场景，如「构建耗时长｜CI 容器」。
+2. 前置条件一致，且标题相同、标题字片重合 ≥ 0.6、或摘要重合 ≥ 0.75 → 合并。
+3. 只共用项目名不算合并（「插件市场条目字段」对「插件市场踩坑清单」重合约 0.4）。
+4. 判不准先 `memory_search`：命中且场景一致，就按那条的标题和场景写；不一致就新建。
+
+合并只做增添，绝不整篇覆盖：
+
+- 旧正文全留下；这次只写新增的要点。
+- `- 键：值` 形式的行，键相同则以新的为准（端口改了、路径改了）。
+- 真要把一条记忆作废重写（不是补充），先 `memory_forget` 再 `memory_save`，别用合并去覆盖。
 
 ## 频率与退让
 

package/index.js

@@ -114,6 +114,7 @@ const SAVE_PARAMS = {
     title: { type: 'string', description: `标题：名词短语，用户一眼能认出是哪件事，不超过 ${LIMITS.titleChars} 字` },
     summary: { type: 'string', description: `一句话说清要记的内容本身——用户只看这一行决定留不留，名词短语，不超过 ${LIMITS.summaryChars} 字` },
     body: { type: 'string', description: '正文 markdown。只写指针与要点，不抄录长文档' },
+    when: { type: 'string', description: `前置条件或适用场景（「在哪台机器 / 哪个环境 / 什么情况下」），不超过 ${LIMITS.whenChars} 字。同一主题但前置条件不同，会存成两条，不合并` },
     kind: { type: 'string', enum: ['preference', 'convention', 'procedure', 'pointer', 'pitfall', 'credential_hint', 'note'], description: '条目类型' },
     tags: { type: 'array', items: { type: 'string' }, description: '最多 5 个标签' },
   },
@@ -156,7 +157,7 @@ export function apply(ctx) {
 
   ctx.effect(() => tools.register({
     name: 'memory_save',
-    description: `保存一条记忆。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。用户点了「保留」或发「保留记忆「X」」时，用那条建议的内容调用。更新已知主题时先 memory_read 旧正文再写：标题相同、或标题与摘要高度相近时，会合并进原来那条（merges+1），正文整篇替换，不新增条目。${NOTES}`,
+    description: `保存一条记忆。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。用户点了「保留」或发「保留记忆「X」」时，用那条建议的内容调用。更新已知主题时先 memory_read 旧正文再写：标题相同、或标题与摘要高度相近、且前置条件一致时，会合并进原来那条（merges+1），旧要点保留，同键的新值覆盖。前置条件不同的同一主题是两条，不要硬合并。正文只写这次新增的要点。${NOTES}`,
     parameters: SAVE_PARAMS,
     output: {
       schema: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "On-demand memory for the DeepSeek Harness: nothing in the system prompt, one muted line only when something is saved, hit or suggested.",
   "type": "module",
   "main": "index.js",

package/store.js

@@ -12,6 +12,7 @@ export const LIMITS = {
   entryBytes: 4096,
   totalBytes: 512 * 1024,
   titleChars: 40,
+  whenChars: 60,
   summaryChars: 60,
   suggestionWindowMs: 48 * 60 * 60 * 1000,
 };
@@ -147,11 +148,15 @@ function similarity(a, b) {
   return shared / (left.size + right.size - shared);
 }
 
-/** 同标题必合并；否则标题或摘要够像，也当作同一主题的又一次记录。 */
-function mergeCandidate(entries, title, summary) {
+/**
+ * 同一主题的判定。前置条件必须一致：同一件事在不同场景下是两条记忆，
+ * 哪怕正文互相看不上眼，也不能合并成一条。
+ */
+function mergeCandidate(entries, title, summary, when) {
   let best = null;
   let bestScore = 0;
   for (const item of entries) {
+    if ((item.when || '') !== when) continue;
     if (item.title === title) return item;
     const titleScore = similarity(item.title, title);
     const summaryScore = similarity(item.summary, summary);
@@ -165,10 +170,29 @@ function mergeCandidate(entries, title, summary) {
   return best;
 }
 
-/**
- * Save or merge one memory. A repeat of an existing topic updates it and counts
- * the merge instead of adding a row, which is what keeps a long-lived store tidy.
- */
+/** 合并只做增添：旧要点全留下；同一个键（`- 键：值`）的新值覆盖旧值。 */
+export function mergeBody(oldBody, incoming) {
+  const keyOf = (line) => {
+    const match = /^\s*[-*]\s*([^：:]{1,20})[：:]/.exec(line);
+    return match ? match[1].trim() : null;
+  };
+  const flat = (line) => line.replace(/\s+/g, ' ').trim();
+  const out = String(oldBody || '').split('\n').filter((line) => line.trim());
+  for (const raw of String(incoming || '').split('\n')) {
+    const line = raw.trim();
+    if (!line) continue;
+    const key = keyOf(line);
+    if (key) {
+      const at = out.findIndex((item) => keyOf(item) === key);
+      if (at >= 0) out[at] = line;
+      else out.push(line);
+      continue;
+    }
+    if (!out.some((item) => flat(item) === flat(line))) out.push(line);
+  }
+  return out.join('\n');
+}
+
 export function upsert(scope, draft) {
   const title = normalizeText(draft.title, LIMITS.titleChars);
   if (!title) throw new Error('标题为空');
@@ -179,13 +203,18 @@ export function upsert(scope, draft) {
   const asSecret = detectSecret(`${title}\n${summary.text}\n${body}`);
   if (asSecret) throw new Error(`检出疑似凭据，未保存（${asSecret}）。凭据只记位置与调用方式`);
 
+  const when = normalizeText(draft.when ?? '', LIMITS.whenChars);
   const index = loadIndex(scope);
   const now = new Date().toISOString();
-  const existing = mergeCandidate(index.entries, title, summary.text);
+  const existing = mergeCandidate(index.entries, title, summary.text, when);
   const id = existing ? existing.id : `mem_${Date.now().toString(36)}${crypto.randomBytes(2).toString('hex')}`;
+  const stated = existing ? fs.readFileSync(entryFile(scope, id), 'utf8') : '';
+  const mergedBody = existing ? mergeBody(stated, body) : body;
+  if (Buffer.byteLength(mergedBody, 'utf8') > LIMITS.entryBytes) throw new Error(`合并后超过 ${LIMITS.entryBytes} 字：只写这次新增的要点，或先归档旧条目`);
   const record = {
     id,
-    title,
+    title: existing ? existing.title : when ? `${title}｜${when}`.slice(0, LIMITS.titleChars) : title,
+    when,
     summary: summary.text,
     kind: draft.kind || 'note',
     tags: Array.isArray(draft.tags) ? draft.tags.map((tag) => normalizeText(tag, 20)).filter(Boolean).slice(0, 5) : [],
@@ -194,9 +223,9 @@ export function upsert(scope, draft) {
     lastUsed: now,
     hits: existing ? existing.hits || 0 : 0,
     merges: existing ? (existing.merges || 0) + 1 : 0,
-    bytes: Buffer.byteLength(body, 'utf8'),
+    bytes: Buffer.byteLength(mergedBody, 'utf8'),
   };
-  writeAtomic(entryFile(scope, id), body);
+  writeAtomic(entryFile(scope, id), mergedBody);
   if (existing) index.entries = index.entries.map((item) => (item.id === id ? record : item));
   else index.entries.push(record);
   index.suggestions = (index.suggestions || []).filter((item) => item.title !== title).slice(-19);
@@ -212,7 +241,7 @@ export function search(scope, query, limit = 4) {
     .split(/[^\p{L}\p{N}]+/u)
     .filter((word) => word.length > 1);
   const scored = index.entries.map((item) => {
-    const hay = `${item.title} ${item.summary} ${(item.tags || []).join(' ')}`.toLowerCase();
+    const hay = `${item.title} ${item.summary} ${item.when || ''} ${(item.tags || []).join(' ')}`.toLowerCase();
     let score = 0;
     for (const term of terms) if (hay.includes(term)) score += term.length > 2 ? 2 : 1;
     if (terms.length > 0 && score === 0) score = similarity(item.title, query) > 0.5 ? 1 : 0;
@@ -297,7 +326,8 @@ export function renderIndex(entries, budget = 400) {
   for (const item of entries) {
     const last = Date.parse(item.lastUsed || item.updated || item.created || '') || now;
     const stale = now - last > staleMs;
-    const line = stale ? `- ${item.id} ${item.title}` : `- ${item.id} ${item.title}｜${item.summary}`;
+    const head = item.when ? `${item.title}（${item.when}）` : item.title;
+    const line = stale ? `- ${item.id} ${head}` : `- ${item.id} ${head}｜${item.summary}`;
     if (used + line.length > budget) break;
     lines.push(line);
     used += line.length + 1;

package/test/store.test.mjs

@@ -78,3 +78,26 @@ assert.equal(sibling.merged, false);
 assert.equal(store.loadIndex(mergeScope).entries.length, 2);
 
 console.log('store: merge rules ok');
+
+// 前置条件不同 → 两条，哪怕标题一样。
+const mac = store.upsert(mergeScope, { title: '构建耗时长', summary: '本机构建要几分钟', when: 'macOS 本地', body: '- 原因：磁盘加密' });
+const ci = store.upsert(mergeScope, { title: '构建耗时长', summary: '本机构建要几分钟', when: 'CI 容器', body: '- 原因：冷缓存' });
+assert.equal(mac.merged, false);
+assert.equal(ci.merged, false);
+assert.notEqual(ci.record.id, mac.record.id);
+assert.equal(store.loadIndex(mergeScope).entries.filter((item) => item.title.startsWith('构建耗时长')).length, 2);
+
+// 同一前置条件下合并：旧要点保留，同键覆盖。
+const plus = store.upsert(mergeScope, { title: '构建耗时长', summary: '本机构建要几分钟', when: 'macOS 本地', body: '- 绕过：先跑 cache\n- 原因：磁盘加密拖慢' });
+assert.equal(plus.merged, true);
+assert.equal(plus.record.id, mac.record.id);
+const body = store.readEntry(mergeScope, mac.record.id).body;
+assert.match(body, /绕过/);
+assert.match(body, /磁盘加密拖慢/);
+assert.equal(body.includes('磁盘加密\n'), false);
+
+// 前置条件参与检索。
+const hit = store.search(mergeScope, 'CI 容器');
+assert.ok(hit.some((item) => item.id === ci.record.id));
+
+console.log('store: precondition rules ok');