@modusensus/dsh-mneme 0.5.0 → 0.5.2

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/hot-memory.test.js

@@ -1,145 +1,174 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createHotMemory, estimateTokens } from "../src/hot-memory.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createVectorIndex } from "../src/vector-index.js";
-
-// --- hot memory buffer ---
-
-test("hot memory keeps the latest rounds within maxRounds", () => {
-  const hot = createHotMemory({ maxRounds: 2, maxTokens: 10000 });
-  hot.add({ query: "第一轮", response: "答一" });
-  hot.add({ query: "第二轮", response: "答二" });
-  hot.add({ query: "第三轮", response: "答三" });
-  assert.equal(hot.rounds().length, 2);
-  assert.ok(hot.getContext().includes("第三轮"));
-  assert.ok(!hot.getContext().includes("第一轮"));
-});
-
-test("hot memory enforces the token budget", () => {
-  const hot = createHotMemory({ maxRounds: 10, maxTokens: 30 });
-  hot.add({ query: "很长的第一轮问题".repeat(10), response: "很长的回答".repeat(10) });
-  hot.add({ query: "第二轮", response: "答二" });
-  // The first round alone blows the budget; the newest round survives and
-  // the buffer never empties completely.
-  const rounds = hot.rounds();
-  assert.ok(rounds.length >= 1);
-  assert.equal(rounds[rounds.length - 1].query, "第二轮");
-});
-
-test("hot memory getContext uses the Q/A round format", () => {
-  const hot = createHotMemory({ maxRounds: 5, maxTokens: 10000 });
-  hot.add({ query: "Q1", response: "A1" });
-  hot.add({ query: "Q2", response: "A2" });
-  assert.equal(hot.getContext(), "Q: Q1\nA: A1\n\nQ: Q2\nA: A2");
-});
-
-test("hot memory ignores empty rounds and clears", () => {
-  const hot = createHotMemory({ maxRounds: 5, maxTokens: 10000 });
-  hot.add({ query: "", response: "x" });
-  hot.add(null);
-  assert.equal(hot.rounds().length, 0);
-  hot.add({ query: "q" });
-  hot.clear();
-  assert.equal(hot.getContext(), "");
-});
-
-test("estimateTokens counts CJK heavier than ASCII", () => {
-  assert.ok(estimateTokens("中文内容") > estimateTokens("abcd"));
-});
-
-// --- service-level: BM25 fusion + semantic dedup + selective injection ---
-
-function toyVec(text) {
-  const v = new Array(64).fill(0);
-  for (const t of String(text).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean)) {
-    let h = 0;
-    for (const ch of t) h = (h * 31 + ch.codePointAt(0)) >>> 0;
-    v[h % 64] += 1;
-  }
-  const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0)) || 1;
-  return v.map((x) => x / norm);
-}
-
-function setup(overrides = {}) {
-  const store = createStore(":memory:");
-  const config = {
-    entitySearchEnabled: false,
-    bm25SearchEnabled: true,
-    adaptiveThresholdEnabled: false,
-    searchSemanticDedup: true,
-    selectiveInjectEnabled: true,
-    ...overrides
-  };
-  const service = createService({ store, mirror: null, config, logger: null });
-  service.setVectorIndex(createVectorIndex({ store, logger: null }));
-  service.setEmbedder({ embedSingle: async (t) => toyVec(t) });
-  return { store, service };
-}
-
-test("searchMemories fuses BM25: scattered-term queries recall both rows", async () => {
-  const { store, service } = setup();
-  const a = store.save({ type: "project", title: "异步并发模式", content: "async runtime 选用 tokio", importance: 3 });
-  const b = store.save({ type: "decision", title: "语言迁移", content: "编译模块迁移到 Rust", importance: 3 });
-  store.save({ type: "project", title: "无关", content: "夜间 ETL 脚本", importance: 3 });
-
-  // "rust 异步" is not a substring of either row — LIKE misses both; BM25
-  // must surface both rows in the merged result.
-  const results = await service.searchMemories("rust 异步", { mode: "auto", topK: 5 });
-  const ids = results.map((r) => r.id);
-  assert.ok(ids.includes(a.id), "async row must be recalled via BM25");
-  assert.ok(ids.includes(b.id), "rust row must be recalled via BM25");
-  assert.equal(results.find((r) => r.id === a.id)?.source, "bm25");
-});
-
-test("bm25SearchEnabled=false restores the two-path behavior", async () => {
-  const { store, service } = setup({ bm25SearchEnabled: false });
-  const a = store.save({ type: "project", title: "异步并发模式", content: "async runtime 选用 tokio", importance: 3 });
-  const results = await service.searchMemories("rust 异步", { mode: "auto", topK: 5 });
-  assert.ok(!results.some((r) => r.id === a.id), "no BM25 → scattered-term miss is back");
-});
-
-test("search-time semantic dedup drops near-identical embeddings", async () => {
-  const { store, service } = setup();
-  const a = store.save({ type: "project", title: "偏好 A", content: "用户喜欢深色主题编辑器", importance: 3 });
-  const b = store.save({ type: "project", title: "偏好 A 备份", content: "用户喜欢深色主题编辑器（备份）", importance: 3 });
-  store.setEmbedding(a.id, toyVec("用户喜欢深色主题编辑器"));
-  store.setEmbedding(b.id, toyVec("用户喜欢深色主题编辑器"));
-
-  // auto (not keyword): keyword mode is the documented text-only path and is
-  // exempt from dedup by design; auto exercises the dedup the way production
-  // searches run.
-  const results = await service.searchMemories("深色主题", { mode: "auto", topK: 5 });
-  const ids = results.map((r) => r.id);
-  assert.ok(ids.includes(a.id) !== ids.includes(b.id), "one of the near-duplicate pair is dropped");
-});
-
-test("searchSemanticDedup=false keeps duplicate embeddings", async () => {
-  const { store, service } = setup({ searchSemanticDedup: false });
-  const a = store.save({ type: "project", title: "偏好 A", content: "用户喜欢深色主题编辑器", importance: 3 });
-  const b = store.save({ type: "project", title: "偏好 A 备份", content: "用户喜欢深色主题编辑器（备份）", importance: 3 });
-  store.setEmbedding(a.id, toyVec("用户喜欢深色主题编辑器"));
-  store.setEmbedding(b.id, toyVec("用户喜欢深色主题编辑器"));
-  const results = await service.searchMemories("深色主题", { mode: "keyword", topK: 5 });
-  assert.equal(results.length, 2);
-});
-
-test("selective injection re-orders candidates by query similarity", () => {
-  const { store, service } = setup();
-  const thesis = store.save({ type: "project", title: "湿地论文", content: "毕业论文研究城市湿地公园", importance: 5 });
-  const plugin = store.save({ type: "project", title: "插件项目", content: "dsh-mneme 记忆插件开发", importance: 5 });
-  store.setEmbedding(thesis.id, toyVec("毕业论文研究城市湿地公园"));
-  store.setEmbedding(plugin.id, toyVec("dsh-mneme 记忆插件开发"));
-
-  // Rule-based order would put both at equal importance; the query vector is
-  // about the thesis, so topic ranking must put the thesis memory first.
-  const picked = service.injectCandidates({
-    query: "论文写作",
-    queryVector: toyVec("毕业论文研究城市湿地公园"),
-    maxItems: 2,
-    threshold: 3
-  });
-  assert.equal(picked[0].id, thesis.id);
-  assert.ok(picked.some((m) => m.id === plugin.id));
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createHotMemory, estimateTokens } from "../src/hot-memory.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// --- hot memory buffer ---
+
+test("hot memory keeps the latest rounds within maxRounds", () => {
+  const hot = createHotMemory({ maxRounds: 2, maxTokens: 10000 });
+  hot.add({ query: "第一轮", response: "答一" });
+  hot.add({ query: "第二轮", response: "答二" });
+  hot.add({ query: "第三轮", response: "答三" });
+  assert.equal(hot.rounds().length, 2);
+  assert.ok(hot.getContext().includes("第三轮"));
+  assert.ok(!hot.getContext().includes("第一轮"));
+});
+
+test("hot memory enforces the token budget", () => {
+  const hot = createHotMemory({ maxRounds: 10, maxTokens: 30 });
+  hot.add({ query: "很长的第一轮问题".repeat(10), response: "很长的回答".repeat(10) });
+  hot.add({ query: "第二轮", response: "答二" });
+  // The first round alone blows the budget; the newest round survives and
+  // the buffer never empties completely.
+  const rounds = hot.rounds();
+  assert.ok(rounds.length >= 1);
+  assert.equal(rounds[rounds.length - 1].query, "第二轮");
+});
+
+test("hot memory getContext uses the Q/A round format", () => {
+  const hot = createHotMemory({ maxRounds: 5, maxTokens: 10000 });
+  hot.add({ query: "Q1", response: "A1" });
+  hot.add({ query: "Q2", response: "A2" });
+  assert.equal(hot.getContext(), "Q: Q1\nA: A1\n\nQ: Q2\nA: A2");
+});
+
+test("hot memory ignores empty rounds and clears", () => {
+  const hot = createHotMemory({ maxRounds: 5, maxTokens: 10000 });
+  hot.add({ query: "", response: "x" });
+  hot.add(null);
+  assert.equal(hot.rounds().length, 0);
+  hot.add({ query: "q" });
+  hot.clear();
+  assert.equal(hot.getContext(), "");
+});
+
+test("estimateTokens counts CJK heavier than ASCII", () => {
+  assert.ok(estimateTokens("中文内容") > estimateTokens("abcd"));
+});
+
+// --- entry defense: non-positive / non-integer bounds fall back to defaults ---
+// Bug: createHotMemory({ maxRounds: -1 }) made the eviction while-loop
+// `while (buffer.length > maxRounds)` unbounded — after the buffer emptied,
+// `0 > -1` stayed true and buffer.shift() on an empty array is a no-op, so
+// every add() spun forever. Non-integer values (1.5, NaN, null) were also
+// silently wrong. The fix clamps them to the 5/2000 defaults at the door.
+
+test("hot memory falls back to maxRounds=5 for non-positive/invalid values", () => {
+  for (const bad of [0, -1, 1.5, NaN, null]) {
+    const hot = createHotMemory({ maxRounds: bad, maxTokens: 10000 });
+    for (let i = 0; i < 8; i++) hot.add({ query: `第${i}轮`, response: "x" });
+    assert.equal(hot.rounds().length, 5, `maxRounds=${bad} must fall back to 5, no infinite loop`);
+    assert.ok(hot.getContext().includes("第7轮"), `maxRounds=${bad}: newest round survives`);
+    assert.ok(!hot.getContext().includes("第0轮"), `maxRounds=${bad}: oldest round evicted`);
+  }
+});
+
+test("hot memory falls back to maxTokens=2000 for non-positive/infinite values", () => {
+  for (const bad of [0, -1, Infinity]) {
+    const hot = createHotMemory({ maxRounds: 50, maxTokens: bad });
+    // 50 rounds at ~74 tokens each blow a 2000-token budget; the fallback must
+    // evict into (1, 50). A broken budget of 0/-1 would squeeze to 1 round and
+    // Infinity would keep all 50 — both are the pre-fix behavior.
+    for (let i = 0; i < 50; i++) hot.add({ query: `第${i}轮`, response: "长回答".repeat(40) });
+    const n = hot.rounds().length;
+    assert.ok(n > 1 && n < 50, `maxTokens=${bad} falls back to 2000 (kept ${n} rounds)`);
+  }
+});
+
+// --- service-level: BM25 fusion + semantic dedup + selective injection ---
+
+function toyVec(text) {
+  const v = new Array(64).fill(0);
+  for (const t of String(text).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean)) {
+    let h = 0;
+    for (const ch of t) h = (h * 31 + ch.codePointAt(0)) >>> 0;
+    v[h % 64] += 1;
+  }
+  const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0)) || 1;
+  return v.map((x) => x / norm);
+}
+
+function setup(overrides = {}) {
+  const store = createStore(":memory:");
+  const config = {
+    entitySearchEnabled: false,
+    bm25SearchEnabled: true,
+    adaptiveThresholdEnabled: false,
+    searchSemanticDedup: true,
+    selectiveInjectEnabled: true,
+    ...overrides
+  };
+  const service = createService({ store, mirror: null, config, logger: null });
+  service.setVectorIndex(createVectorIndex({ store, logger: null }));
+  service.setEmbedder({ embedSingle: async (t) => toyVec(t) });
+  return { store, service };
+}
+
+test("searchMemories fuses BM25: scattered-term queries recall both rows", async () => {
+  const { store, service } = setup();
+  const a = store.save({ type: "project", title: "异步并发模式", content: "async runtime 选用 tokio", importance: 3 });
+  const b = store.save({ type: "decision", title: "语言迁移", content: "编译模块迁移到 Rust", importance: 3 });
+  store.save({ type: "project", title: "无关", content: "夜间 ETL 脚本", importance: 3 });
+
+  // "rust 异步" is not a substring of either row — LIKE misses both; BM25
+  // must surface both rows in the merged result.
+  const results = await service.searchMemories("rust 异步", { mode: "auto", topK: 5 });
+  const ids = results.map((r) => r.id);
+  assert.ok(ids.includes(a.id), "async row must be recalled via BM25");
+  assert.ok(ids.includes(b.id), "rust row must be recalled via BM25");
+  assert.equal(results.find((r) => r.id === a.id)?.source, "bm25");
+});
+
+test("bm25SearchEnabled=false restores the two-path behavior", async () => {
+  const { store, service } = setup({ bm25SearchEnabled: false });
+  const a = store.save({ type: "project", title: "异步并发模式", content: "async runtime 选用 tokio", importance: 3 });
+  const results = await service.searchMemories("rust 异步", { mode: "auto", topK: 5 });
+  assert.ok(!results.some((r) => r.id === a.id), "no BM25 → scattered-term miss is back");
+});
+
+test("search-time semantic dedup drops near-identical embeddings", async () => {
+  const { store, service } = setup();
+  const a = store.save({ type: "project", title: "偏好 A", content: "用户喜欢深色主题编辑器", importance: 3 });
+  const b = store.save({ type: "project", title: "偏好 A 备份", content: "用户喜欢深色主题编辑器（备份）", importance: 3 });
+  store.setEmbedding(a.id, toyVec("用户喜欢深色主题编辑器"));
+  store.setEmbedding(b.id, toyVec("用户喜欢深色主题编辑器"));
+
+  // auto (not keyword): keyword mode is the documented text-only path and is
+  // exempt from dedup by design; auto exercises the dedup the way production
+  // searches run.
+  const results = await service.searchMemories("深色主题", { mode: "auto", topK: 5 });
+  const ids = results.map((r) => r.id);
+  assert.ok(ids.includes(a.id) !== ids.includes(b.id), "one of the near-duplicate pair is dropped");
+});
+
+test("searchSemanticDedup=false keeps duplicate embeddings", async () => {
+  const { store, service } = setup({ searchSemanticDedup: false });
+  const a = store.save({ type: "project", title: "偏好 A", content: "用户喜欢深色主题编辑器", importance: 3 });
+  const b = store.save({ type: "project", title: "偏好 A 备份", content: "用户喜欢深色主题编辑器（备份）", importance: 3 });
+  store.setEmbedding(a.id, toyVec("用户喜欢深色主题编辑器"));
+  store.setEmbedding(b.id, toyVec("用户喜欢深色主题编辑器"));
+  const results = await service.searchMemories("深色主题", { mode: "keyword", topK: 5 });
+  assert.equal(results.length, 2);
+});
+
+test("selective injection re-orders candidates by query similarity", () => {
+  const { store, service } = setup();
+  const thesis = store.save({ type: "project", title: "湿地论文", content: "毕业论文研究城市湿地公园", importance: 5 });
+  const plugin = store.save({ type: "project", title: "插件项目", content: "dsh-mneme 记忆插件开发", importance: 5 });
+  store.setEmbedding(thesis.id, toyVec("毕业论文研究城市湿地公园"));
+  store.setEmbedding(plugin.id, toyVec("dsh-mneme 记忆插件开发"));
+
+  // Rule-based order would put both at equal importance; the query vector is
+  // about the thesis, so topic ranking must put the thesis memory first.
+  const picked = service.injectCandidates({
+    query: "论文写作",
+    queryVector: toyVec("毕业论文研究城市湿地公园"),
+    maxItems: 2,
+    threshold: 3
+  });
+  assert.equal(picked[0].id, thesis.id);
+  assert.ok(picked.some((m) => m.id === plugin.id));
+});

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 });
+});