@modusensus/dsh-mneme 0.6.11 → 0.7.0

package/{test → dsh-mneme/test}/recall-layer.test.js

@@ -77,14 +77,23 @@ test("recorded candidates carry id/title/content/score/source and match the retu
   assert.ok(cands.some((c) => c.id === b.id), "second memory recorded");
 });
 
-test("recordRecall defaults to off — recorder is not called", async () => {
+test("recordRecall defaults on (v0.7.0) — recorder is called by default", async () => {
   const { service } = setup();
   let calls = 0;
   service.setRecallRecorder(() => calls++);
   saveMemory(service, null, { title: "量子计算", content: "入门" });
   await service.searchMemories("量子", { mode: "keyword" });
+  assert.equal(calls, 1, "recorder called once by default (recall_runs 记录默认开)");
+});
+
+test("recordRecall can be opted out via explicit false or config.recallRecordDefault=false", async () => {
+  const { service } = setup({ recallRecordDefault: false });
+  let calls = 0;
+  service.setRecallRecorder(() => calls++);
+  saveMemory(service, null, { title: "量子计算", content: "入门" });
+  await service.searchMemories("量子", { mode: "keyword" });
   await service.searchMemories("量子", { mode: "keyword", recordRecall: false });
-  assert.equal(calls, 0, "no recorder call when recordRecall is unset or false");
+  assert.equal(calls, 0, "no recorder call when default disabled or explicit false");
 });
 
 test("recordRecall=true with no recorder installed is safe and returns normally", async () => {
@@ -301,7 +310,7 @@ test("e2e: index.js wiring — recordRecall search lands a row listRecallRuns ca
   assert.equal(store.getRecallRun(run.id).query, "量子", "row readable right away");
 });
 
-test("e2e: without recordRecall the recall_runs table gains no rows", async () => {
+test("e2e: recordRecall defaults on (v0.7.0) but is disabled by config.recallRecordDefault=false", async () => {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
   service.setRecallRecorder((recall) => store.saveRecallRun({
@@ -310,6 +319,18 @@ test("e2e: without recordRecall the recall_runs table gains no rows", async () =
   }));
   service.saveWithDedupe({ type: "preference", title: "量子计算入门", content: "叠加态" });
   await service.searchMemories("量子", { mode: "keyword" });
-  await service.searchMemories("量子", { mode: "keyword", recordRecall: false });
-  assert.deepEqual(store.listRecallRuns(), [], "no rows without recordRecall=true");
+  assert.equal(store.listRecallRuns().length, 1, "default config records a row (记录默认开)");
+
+  const store2 = createStore(":memory:");
+  const service2 = createService({ store: store2, mirror: null, config: { recallRecordDefault: false } });
+  service2.setRecallRecorder((recall) => store2.saveRecallRun({
+    query: recall.query, mode: recall.mode, topK: recall.topK, threshold: recall.threshold ?? null,
+    candidates: recall.candidates ?? [], created_at: recall.createdAt
+  }));
+  service2.saveWithDedupe({ type: "preference", title: "量子计算入门", content: "叠加态" });
+  await service2.searchMemories("量子", { mode: "keyword" });
+  await service2.searchMemories("量子", { mode: "keyword", recordRecall: false });
+  assert.deepEqual(store2.listRecallRuns(), [], "no rows when recallRecordDefault=false or explicit false");
+  store.close();
+  store2.close();
 });

package/dsh-mneme/test/recall-runs.test.js

@@ -0,0 +1,93 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// v0.7.0 recall-layer 强度标记 + 滚动清理：
+//   - searchMemories 记搜索帧：candidates 打 injected:false（被召回）；
+//   - injectCandidates 记注入帧：mode="inject"、candidates 打 injected:true
+//     （被注入上下文）—— 两个消耗强度可分可查；
+//   - 两路都受 recallRecordDefault 门控，注入帧记账失败绝不阻断注入；
+//   - store.purgeRecallRunsOlderThan(days) 按 created_at 滚动清理防膨胀。
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function wireRecorder(service, seen) {
+  service.setRecallRecorder((r) => seen.push(r));
+}
+
+test("search scene candidates carry injected:false", async () => {
+  const { service } = setup();
+  const seen = [];
+  wireRecorder(service, seen);
+  service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 });
+  const rows = await service.searchMemories("量子", { mode: "keyword", recordRecall: true });
+  assert.equal(rows.length, 1);
+  assert.equal(seen[0].mode, "keyword");
+  assert.equal(seen[0].candidates[0].injected, false, "搜索帧是被召回的帧，标记 false");
+});
+
+test("inject scene records mode=inject with injected:true on every candidate", async () => {
+  const { service } = setup();
+  const seen = [];
+  wireRecorder(service, seen);
+  const mem = service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 }).memory;
+  const injected = service.injectCandidates({ query: "量子", maxItems: 3 });
+  assert.ok(injected.some((m) => m.id === mem.id), "注入选中的记忆在返回里");
+  assert.equal(seen.length, 1, "注入帧记了 1 条 recall_runs");
+  const rec = seen[0];
+  assert.equal(rec.mode, "inject", "注入帧 mode 为 inject");
+  assert.equal(rec.topK, injected.length);
+  assert.ok(rec.candidates.length >= 1 && rec.candidates.every((c) => c.injected === true), "注入候选全部 injected:true");
+  assert.ok(rec.candidates.every((c) => c.source === "inject"), "注入候选 source 标记 inject");
+});
+
+test("inject recording is gated off by recallRecordDefault=false, search stays explicit", async () => {
+  const { service } = setup({ recallRecordDefault: false });
+  const seen = [];
+  wireRecorder(service, seen);
+  service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 });
+  service.injectCandidates({ query: "量子", maxItems: 3 });
+  assert.equal(seen.length, 0, "recallRecordDefault=false 时注入帧不上报");
+  await service.searchMemories("量子", { mode: "keyword", recordRecall: true });
+  assert.equal(seen.length, 1, "显式 recordRecall:true 的搜索帧照常上报");
+});
+
+test("injected flag survives the store round-trip", async () => {
+  const store = createStore(":memory:");
+  store.saveRecallRun({
+    query: "量子", mode: "inject", topK: 1, candidates: [{ id: "a", title: "量子", content: "入门", score: 0.8, source: "inject", injected: true }]
+  });
+  store.saveRecallRun({
+    query: "量子", mode: "keyword", topK: 1, candidates: [{ id: "b", title: "量子计算", content: "叠加态", score: 0.9, source: "keyword", injected: false }]
+  });
+  const runs = store.listRecallRuns();
+  assert.equal(runs.length, 2);
+  const inject = runs.find((r) => r.mode === "inject");
+  const search = runs.find((r) => r.mode === "keyword");
+  assert.equal(inject.candidates[0].injected, true, "注入帧 injected 存得回来");
+  assert.equal(search.candidates[0].injected, false, "搜索帧 injected 存得回来");
+  assert.equal(store.getRecallRun(search.id).candidates[0].injected, false);
+});
+
+test("purgeRecallRunsOlderThan drops only rows past the retention window", async () => {
+  const store = createStore(":memory:");
+  const old = store.saveRecallRun({
+    id: "old", query: "旧查询", mode: "keyword", topK: 5, candidates: [],
+    created_at: new Date(Date.now() - 200 * 86400000).toISOString()
+  });
+  const fresh = store.saveRecallRun({
+    id: "fresh", query: "新查询", mode: "inject", topK: 5, candidates: [],
+    created_at: new Date().toISOString()
+  });
+  const deleted = store.purgeRecallRunsOlderThan(90);
+  assert.equal(deleted, 1, "只有 200 天前的老行被清除");
+  const runs = store.listRecallRuns();
+  assert.deepEqual(runs.map((r) => r.id), ["fresh"], "新行保留");
+  assert.equal(store.getRecallRun(old.id), undefined, "旧行不可再读");
+  store.close();
+});

package/dsh-mneme/test/sleep-heat.test.js

@@ -0,0 +1,112 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runSleep } from "../src/dream/sleep.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// v0.7.0 待办③ sleep 降级热联合判定：
+//   降级需同时满足 时间窗 + heat<sleepHeatThreshold + importance<5 三条件；
+//   λ=0 的免疫类型 heat 恒 1.0 天然豁免；importance≥5 紧要记忆无论多冷都保留。
+// 默认 λ 下：history(0.006) 约 77 天后热值跌破 0.05，project(0.0008) 约 581 天，
+// decision(0.002) 约 232 天 —— 整体取向保守，突出"冷但重要"与"热但低值"都不降级。
+
+const DAY = 86400000;
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function saveMemory(service, title, content, type = "project", importance = 3) {
+  return service.saveWithDedupe({ type, title, content, importance }).memory;
+}
+
+function sleepConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,   // 30-90 天窗口 → 压缩为摘要
+    sleepCompressDays: 90,  // >=90 天 → 直接归档
+    sleepPatternMinMemories: 100, // 记忆数不足 → pattern 阶段跳过
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+function mockCtx() {
+  return {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+async function run(memories, service, config) {
+  const now = Date.now();
+  for (const [mem, daysAgo] of memories) {
+    service.touchLastAccess(mem.id, new Date(now - daysAgo * DAY).toISOString());
+  }
+  const result = await runSleep(mockCtx(), service, config, { warn: () => {}, info: () => {} }, null, null);
+  return result.phases?.["demotion"];
+}
+
+test("cold low-importance history past the compress tier archives (heat gate open)", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "久远的会话记录", "早期讨论内容", "history", 2);
+  const demotion = await run([[mem, 120]], service, sleepConfig());
+  assert.ok(demotion, "demotion phase ran");
+  assert.ok(demotion.archived.includes(mem.id), "120 天 ref + 热值≈0.03<0.05 + importance 2 → 归档");
+  assert.equal(store.getById(mem.id).archived, true);
+  store.close();
+});
+
+test("importance 5 protects a memory even when the heat is icy", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "关键决策", "不可丢失的重要结论", "decision", 5);
+  const demotion = await run([[mem, 400]], service, sleepConfig());
+  assert.ok(demotion, "demotion phase ran");
+  // decision λ=0.002, 400 天热值≈0.03<0.05，但 importance=5 → 保护，绝不降级。
+  assert.ok(!demotion.archived.includes(mem.id), "紧要记忆不被归档");
+  assert.ok(!demotion.demoted.includes(mem.id), "紧要记忆不被压缩");
+  assert.equal(store.getById(mem.id).archived, false);
+  store.close();
+});
+
+test("immune preference (λ=0, heat=1.0) is never demoted even when ancient", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "用户偏好", "喜欢简洁的总结", "preference", 3);
+  const demotion = await run([[mem, 400]], service, sleepConfig());
+  assert.ok(!demotion.archived.includes(mem.id), "免疫类型不归档");
+  assert.ok(!demotion.demoted.includes(mem.id), "免疫类型不压缩");
+  assert.equal(store.getById(mem.id).archived, false);
+  store.close();
+});
+
+test("slow-decay project stays heat-protected at the compress tier (λ=0.0008)", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "项目A", "慢衰减的进行中项目", "project", 2);
+  const demotion = await run([[mem, 100]], service, sleepConfig());
+  // 100 天已越过 90 天归档窗，但 project 热值≈0.28>0.05 → heat 闸拦下。
+  assert.ok(!demotion.archived.includes(mem.id), "慢衰减类型热值仍高 → 不归档");
+  assert.equal(store.getById(mem.id).archived, false);
+  store.close();
+});
+
+test("demote tier (30-90d) fires when the type's λ is cold enough", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "中期会话摘要", "可压缩的历史碎片", "history", 2);
+  // 调高 history 的 λ 到 0.05 → 40 天热值≈0.009<0.05，解锁 30-90 天压缩窗口。
+  const config = sleepConfig({ heatTypeDecay: { history: 0.05 } });
+  const demotion = await run([[mem, 40]], service, config);
+  assert.ok(!demotion.archived.includes(mem.id), "40 天未到归档线");
+  assert.ok(demotion.demoted.includes(mem.id), "热值足够冷 + importance 2 → 压缩为摘要");
+  const after = store.getById(mem.id);
+  assert.ok(after._full_content, "全文停放在 _full_content");
+  store.close();
+});

package/{test → dsh-mneme/test}/sleep.test.js

@@ -45,6 +45,14 @@ function baseConfig(overrides = {}) {
   };
 }
 
+// v0.7.0 热联合判定：慢衰减类型（project λ=0.0008）默认受热闸保护——40 天热值
+// ≈0.5、100 天 ≈0.28，始终高于 sleepHeatThreshold(0.05)，demotion 不触发。
+// 降级语义测试把 project 的 λ 调快到 0.02（40 天热值≈0.03），复现"时间窗冷态
+// 即降级"的旧路径；默认保守语义由 sleep-heat.test.js 单独覆盖。
+function demotionConfig(overrides = {}) {
+  return baseConfig({ heatTypeDecay: { project: 0.02 }, ...overrides });
+}
+
 function setup() {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
@@ -173,7 +181,7 @@ test("sleep: demotion shrinks cold memory to summary, keeps _full_content", asyn
   const m = makeMemory(service, "cold", "原内容".repeat(60), "project");
   service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
   const ctx = mockCtx(() => "[]");
-  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
   const after = service.getById(m.id);
   assert.equal(result.status, "ok");
   assert.ok(after._full_content && after._full_content.length > 0, "full body preserved");
@@ -188,7 +196,7 @@ test("sleep: demotion fully archives memory past sleepCompressDays", async () =>
   const m = makeMemory(service, "ancient", "很老的记忆", "project");
   service.touchLastAccess(m.id, new Date(now - 100 * 86400000).toISOString());
   const ctx = mockCtx(() => "[]");
-  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
   const after = service.getById(m.id);
   assert.equal(result.status, "ok");
   assert.equal(after.archived, true, "past compress days → archived");
@@ -275,7 +283,7 @@ test("sleep: a failing phase does not block the others (fail-safe)", async () =>
   const m = makeMemory(service, "cold", "内容".repeat(60), "project");
   service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
   const ctx = mockCtx(() => "[]");
-  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
   assert.equal(result.phases.conflicts.status, "skipped", "conflicts phase degraded gracefully (no usable vectors)");
   assert.equal(result.phases.demotion.status, "ok", "demotion still ran");
   assert.equal(result.status, "ok", "overall run still ok despite conflicts degrading");
@@ -289,7 +297,7 @@ test("sleep: no LLM route skips LLM phases but demotion still runs", async () =>
   const m = makeMemory(service, "cold", "内容".repeat(60), "project");
   service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
   const ctx = mockCtx(() => "[]", null); // currentSelection() → null, no route
-  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
   assert.equal(result.phases.conflicts.status, "skipped", "no llm route → conflicts skipped");
   assert.equal(result.phases.patterns.status, "skipped", "no llm route → patterns skipped");
   assert.equal(result.phases.demotion.status, "ok", "demotion is LLM-free and runs");

package/dsh-mneme/test/updated-at-semantics.test.js

@@ -0,0 +1,113 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runSleep } from "../src/dream/sleep.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// v0.7.0 语义修正（待办④ updated_at 不算访问）：
+//  - merge/update 刷 updated_at 绝不当访问，last_accessed_at 与 updated_at 正交；
+//  - sleep 降级 ref 只用 last_accessed_at ?? created_at，杜绝 autoDream 合并
+//    动作把"刚更新过内容"伪装成"刚被召回"；
+//  - 触达数据采集（touchRecalled）由 heatEnabled 控制，不再依赖 sleepModeEnabled。
+
+const DAY = 86400000;
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function saveMemory(service, title, content, type = "project") {
+  return service.saveWithDedupe({ type, title, content, importance: 3 }).memory;
+}
+
+test("store.update bumps updated_at but never last_accessed_at", () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "项目A", "状态：进行中");
+  assert.equal(mem.last_accessed_at, undefined, "saved memory has no last_accessed_at");
+
+  const touched = service.touchLastAccess(mem.id, new Date(Date.now() - 5 * DAY).toISOString());
+  assert.equal(touched, true, "explicit touch succeeds");
+  const afterTouch = store.getById(mem.id);
+  assert.ok(afterTouch.last_accessed_at, "last_accessed_at set after touch");
+
+  const updatedAtBefore = afterTouch.updated_at;
+  store.update(mem.id, { content: "状态：已交付" });
+  const afterUpdate = store.getById(mem.id);
+  assert.notEqual(afterUpdate.updated_at, updatedAtBefore, "updated_at changed by update");
+  assert.equal(
+    afterUpdate.last_accessed_at,
+    afterTouch.last_accessed_at,
+    "last_accessed_at untouched by update (content change ≠ access)"
+  );
+  store.close();
+});
+
+test("search bumps last_accessed_at by default (heatEnabled on) and is gated off by heatEnabled=false", async () => {
+  // Default config: heatEnabled 默认开 → last_accessed_at 被采集（与 sleep 开关解耦）。
+  const a = setup();
+  saveMemory(a.service, "量子计算", "入门");
+  await a.service.searchMemories("量子", { mode: "keyword" });
+  const rowA = a.store.getById(a.service.all()[0].id);
+  assert.ok(rowA.last_accessed_at, "touch runs with heatEnabled default on even when sleepModeEnabled off");
+  a.store.close();
+
+  // heatEnabled=false → 热路径零写入。
+  const b = setup({ heatEnabled: false });
+  saveMemory(b.service, "量子计算", "入门");
+  await b.service.searchMemories("量子", { mode: "keyword" });
+  const rowB = b.store.getById(b.service.all()[0].id);
+  assert.equal(rowB.last_accessed_at, undefined, "no touch when heatEnabled=false");
+  b.store.close();
+});
+
+test("sleep demotion anchors on last_accessed_at — a merge-bumped updated_at does not reset the fresh clock", async () => {
+  const { store, service } = setup();
+  const now = Date.now();
+  const idle = saveMemory(service, "冷查记忆A", "很久没被召回");
+  // 模拟一次 autoDream 合并：updated_at 刷成"现在"，但真实访问在 100 天前。
+  store.update(idle.id, { content: "合并带来的内容更新" });
+  const wait = saveMemory(service, "冷查记忆B", "40 天未访问");
+
+  service.touchLastAccess(idle.id, new Date(now - 100 * DAY).toISOString());
+  service.touchLastAccess(wait.id, new Date(now - 40 * DAY).toISOString());
+
+  // runSleep 的最低配置：demotion 阶段不需要 LLM/语义，其余阶段会 skip。
+  const ctx = {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  const config = {
+    sleepModeEnabled: true,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 100,
+    sleepMaxPatternPerRun: 3,
+    // v0.7.0 热联合判定：project λ=0.0008 默认太慢衰减，40/100 天热值都高于
+    // 阈值、被热闸保护——本测试只验证"updated_at 不算访问"的 ref 语义，故把
+    // λ 调快到 0.02 打开降级路径（默认保守语义由 sleep-heat.test.js 覆盖）。
+    heatTypeDecay: { project: 0.02 }
+  };
+
+  const result = await runSleep(ctx, service, config, { warn: () => {}, info: () => {} }, null, null);
+
+  const demotion = result.phases?.["demotion"];
+  assert.ok(demotion, "demotion phase ran");
+  // A：last_accessed 100 天前（即使 updated_at 是"现在"）→ 越过 90 天归档线。
+  assert.ok(demotion.archived.includes(idle.id), "A archived by last_accessed_at (updated_at ignored)");
+  const afterA = store.getById(idle.id);
+  assert.equal(afterA.archived, true, "A is archived in store");
+  // B：last_accessed 40 天前 → 进入 30 天压缩窗口，被降级为摘要。
+  assert.ok(demotion.demoted.includes(wait.id), "B demoted in 30d compress window");
+  const afterB = store.getById(wait.id);
+  assert.ok(afterB._full_content, "B full body parked in _full_content");
+  store.close();
+});

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.6.11",
+  "version": "0.7.0",
+  "description": "Structured memory engine for DeepSeek Harness. Offline semantic search, entity-attribute-timeline, autoDream self-consolidation, and human-editable Markdown storage.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -12,23 +12,16 @@
     "url": "https://github.com/modusensus/dsh-mneme/issues"
   },
   "type": "module",
-  "main": "lib/index.js",
+  "main": "./dsh-mneme/lib/index.js",
   "exports": {
     ".": {
-      "default": "./lib/index.js"
+      "default": "./dsh-mneme/lib/index.js"
     },
     "./client": {
-      "default": "./lib/client.js"
+      "default": "./dsh-mneme/lib/client.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./dsh-mneme/package.json"
   },
-  "files": [
-    "lib",
-    "src",
-    "scripts",
-    "test",
-    "cordis.patch.yml"
-  ],
   "dsh": {
     "client": {
       "inject": [
@@ -40,9 +33,20 @@
       "platform": "web"
     },
     "bundle": {
-      "patch": "./cordis.patch.yml"
+      "patch": "./dsh-mneme/cordis.patch.yml"
+    },
+    "marketplace": {
+      "profiles": [
+        "web"
+      ],
+      "requiresBuildApproval": false,
+      "requiresRestart": true,
+      "manualSteps": false
     }
   },
+  "scripts": {
+    "prepublishOnly": "node -e \"const fs=require('fs');const v=JSON.parse(fs.readFileSync('./dsh-mneme/package.json','utf8')).version;const p=JSON.parse(fs.readFileSync('./package.json','utf8'));p.version=v;fs.writeFileSync('./package.json',JSON.stringify(p,null,2)+'\\n')\""
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
@@ -50,31 +54,5 @@
     "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
     "@deepseek-ai/schemastery": "^3.18.1"
-  },
-  "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
-    "@deepseek-ai/schemastery": "^3.18.1",
-    "c8": "^12.0.0"
-  },
-  "scripts": {
-    "sync": "node scripts/sync-lib.js",
-    "prepack": "npm run sync",
-    "test": "node --test test/*.test.js",
-    "test:coverage": "c8 node --test test/*.test.js",
-    "e2e": "node scripts/e2e-dsh.js",
-    "stress": "node scripts/stress-dsh.js"
-  },
-  "dependencies": {
-    "@huggingface/transformers": "^4.2.0"
-  },
-  "overrides": {
-    "adm-zip": "0.6.0"
-  },
-  "c8": {
-    "reporter": ["text", "lcov"]
   }
 }

package/v0.7-plan-2026-08-21.md

@@ -0,0 +1,75 @@
+# dsh-mneme v0.7 版本策划书 + 分工安排（2026-08-21）
+
+> 状态：**待桉桉过目** → 通过后**晚上错峰执行**（兼顾火山 coding plan ~1200 次/5 小时额度，分阶段推进，不在同一时段烧光）。
+> 当前版本：v0.6.6（710 全绿）。本策划基于 README 路线图 + Discussion #21 + 社区 heptaspirit 调研（`docs/AGENT_MEMORY_RESEARCH.md`，已归档为 v0.7 参考输入）。
+
+---
+
+## 一、版本定位（调整：v0.7 不着急，先做 v0.6.7）
+
+**近期先做：v0.6.7 —— Issue #20 面板删除按钮**（兑现对社区 lqs50 的承诺，快速小版本）。
+
+**v0.7 主题：自进化记忆（heat 热度 + 兴趣漂移）—— 桉桉 2026-08-21 拍板：不着急，列为远期**，先把 v0.6.x 的欠账收干净再说。
+
+一句话：v0.7 让记忆库不只是"存得准、召得回"，还能**根据访问热度自我衰减、识别兴趣漂移、降级冷记忆**，进化为会"进化"的记忆体。核心来自 #21（简化幂律 + type 差异化半衰期），社区调研补足数据前提与图谱增强。
+
+**复用承接（不引入新依赖/新概念）：** 全部落在现有 `recall_runs` 表 / `TYPE_DECAY` / sleep 批处理 / `entity_attrs` valid_from-until / api.js 的 ego-BFS 上。图数据库（Neo4j/Graphiti）明确不做——SQLite 递归 CTE 实测够用。
+
+---
+
+## 二、范围拆分
+
+### v0.6.7 —— Issue #20 记忆面板删除按钮（近期，优先做）
+| # | 功能 | 说明 | 承接机制 |
+|---|------|------|----------|
+| ⭐1 | **面板删除按钮** | 记忆库界面**直接删除自己不需要的记忆**（社区 lqs50 提，issue #20 仍 OPEN）。后端 storage/`memory_delete` 工具已有 → **补一个面板 HTTP DELETE 端点 + 前端「选中删除」按钮**（永久删除带二次确认；可挂到目录 view / 详情页）| store.deleteMemory + api.js + 面板 |
+- **验收：** 全绿；面板可选中删除记忆（含目录视图入口）；**收掉 issue #20** 并回帖致谢 lqs50。
+- **依赖关系：** 独立小版本，不需要等 v0.7。夜间一个窗口即可完成。
+
+### v0.7.0 —— heat 热度 + 兴趣漂移核心（远期，⏸ 不着急）
+| # | 功能 | 说明 | 承接机制 |
+|---|------|------|----------|
+| 1 | **heat 模型** | 简化幂律衰减 + `TYPE_DECAY`（type 差异化半衰期）；**公式预留信号接口**（新列/metadata，以后加多信号是增量不重构）| #21 已定方向 |
+| 2 | **recall_runs 数据前提** | 记录**默认开、消费默认关**；candidates 打 **`injected` 标记**（区分"被召回"vs"被注入上下文"两个强度）；**90 天滚动清理**防膨胀 | recall_runs / touchRecalled |
+| 3 | **sleep 降级联合判定** | 现状 30/90 天硬阈值不看 importance/type，高价值 preference 也会被降级 → 改为 `heat<阈值 && importance<5 && type 非免疫`，双保护，仍以时间为主 | sleep 批处理 / archived |
+| 4 | **updated_at 不算访问** | 合并/更新刷 updated_at 不应计为访问，防 autoDream 合并动作干扰新鲜度 | 时间戳语义修正 |
+| 5 | **heat 投影实体层** | 实体热 = 关联记忆 heat 聚合；ego-graph 前端节点大小/明暗随热变化，兴趣漂移**在图上可见**（成本≈0，heat 本就 v0.7 改）| entities 表 + 前端 |
+- **验收：** 全绿（目标 710 → 740+）；heat 全部 opt-in（`heatEnabled` 默认保守开启、不破坏现有）。
+- **状态：** ⏸ 桉桉拍板不着急，先做完 v0.6.x 收尾再启动。
+
+### v0.7.1 —— 图谱数据积累 + 检索/关系增强（次轮）
+| # | 功能 | 说明 | 承接机制 |
+|---|------|------|----------|
+| 6 | **实体提取移入 sleep 批量** | 写入路径实时抽实体成本高 → 挪进 sleep 批量，**写入路径零 LLM 成本**；代价是图谱滞后一个 sleep 周期（长期关系网无感）| sleep LLM 阶段模式 |
+| 7 | **sleep 批量实体消歧** | extractor 目前不合并同义词，全称/简称成孤立节点 → 仿 autoDream 的 winner/loser + 审计，或规则兜底（小写/去空格）| findEntityByName |
+| 8 | **1-hop 邻域回流检索** | `entity:X` 顺带召回相邻实体记忆——把图谱从"展示"变成"召回信号"（差异化价值）| api.js ego-BFS |
+| 9 | **关系时效** | `entity_relations` 补 `valid_until` + `superseded` 标记（不删只标，保留历史回溯），换方案后旧关系不一直挂着 | entity_attrs 的 valid_from/until 模式 |
+- **验收：** 全绿；图谱数据能攒起来，前端可见热投影。
+
+### 远期 / 等 DSH（不在本次做）
+- 跨 workspace 记忆共享（README v0.7.0+ 标注，**等 DSH 支持**）；多模态记忆（本地化定位冲突，排除）；参数化记忆 MemoryLLM（模型层路线，基本放弃）；图数据库/PPR/社区子图（CTE 够用，暂缓）。
+
+---
+
+## 三、分工安排（多模型协作，服从派发架构）
+
+| 角色 | 模型 | 负责 | 量级 |
+|------|------|------|------|
+| **协调 + 方案 + 把关** | qwen3.7-max | 拆任务、定义 heat 公式/TYPE_DECAY 表格/schema、每步评审整合 | 中 |
+| **核心代码 + 复杂测试** | kimi-k3 | heat 模型、sleep 降级判定、1-hop 回流、实体消歧、90 天清理等实现 + 全绿测试 | 高 |
+| **轻量校验/快检** | glm-4.5-air | 小步 diff 校验、配置项联动、回归抽查 | 低 |
+| **文档同步** | qwen3.6-plus | CHANGELOG + README 双表（root+子目录、中英），ROADMAP 状态对 | 低 |
+| **集成 + 发布** | 主模型（Ivresse） | 汇总、核验、**报桉桉批准后**发布；一次只发一个 sub-version | — |
+
+> 派发铁律：发布/改动前先征得桉桉许可；复杂编程/测试派 kimi-k3；REANME/CHANGELOG 根+子目录中英都要同步，避免漏改。
+
+## 四、执行节奏（错峰，尊重 ~1200 次/5 小时）
+- **窗口**：每晚 7 点后 / 周末，一次只推一个 sub-step（先 0.7.0，休息/量量再用 0.7.1）。
+- **每步收尾**：跑全绿 → 更新 CHANGELOG/README → 记 activeContext/progress → 停。
+- **不集中突发**：同一窗口不做超长连续生成，做完即停，额度留着。
+
+---
+
+## 五、待桉桉拍板（已定项已在文内标注）
+✅ 已定：**Issue #20 → v0.6.7**（快速兑现）；**v0.7.0 不着急**（远期，先收 v0.6.x 账）。
+> 剩下细节到真正开工前再定即可：heat 默认开/关、v0.7.0 与 v0.7.1 节奏。