@modusensus/dsh-mneme 0.2.3 → 0.2.5

package/test/store.test.js

@@ -0,0 +1,293 @@
+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";
+
+function openMemory() {
+  return createStore(":memory:");
+}
+
+test("createStore initializes schema and opens db", () => {
+  const store = openMemory();
+  const row = store.db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='memories'"
+  ).get();
+  assert.ok(row, "memories table exists");
+  store.close();
+});
+
+test("save inserts a memory and returns it with id/created_at", () => {
+  const store = openMemory();
+  const saved = store.save({
+    type: "preference",
+    title: "语言",
+    content: "用户用中文交流",
+    tags: ["偏好"],
+    importance: 5,
+    source: "manual"
+  });
+  assert.ok(saved.id, "has id");
+  assert.ok(saved.created_at, "has created_at");
+  assert.equal(saved.type, "preference");
+  assert.equal(store.count(), 1);
+  store.close();
+});
+
+test("getById returns the memory", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "c", importance: 3 });
+  const got = store.getById(saved.id);
+  assert.equal(got.title, "t");
+  assert.equal(got.content, "c");
+  store.close();
+});
+
+test("update modifies fields and bumps updated_at", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "c", importance: 3 });
+  const updated = store.update(saved.id, { content: "new content", importance: 4 });
+  assert.equal(updated.content, "new content");
+  assert.equal(updated.importance, 4);
+  assert.notEqual(updated.updated_at, saved.updated_at);
+  store.close();
+});
+
+test("remove deletes the memory", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "c" });
+  store.remove(saved.id);
+  assert.equal(store.getById(saved.id), undefined);
+  assert.equal(store.count(), 0);
+  store.close();
+});
+
+test("list filters by type and paginates", () => {
+  const store = openMemory();
+  for (let i = 0; i < 5; i++) store.save({ type: "preference", title: `p${i}`, content: "c" });
+  for (let i = 0; i < 3; i++) store.save({ type: "project", title: `j${i}`, content: "c" });
+  assert.equal(store.list({ type: "preference" }).length, 5);
+  assert.equal(store.list({ type: "project" }).length, 3);
+  assert.equal(store.list({ limit: 2 }).length, 2);
+  assert.equal(store.list({ limit: 2, offset: 2 }).length, 2);
+  store.close();
+});
+
+test("setForget toggles injection suppression", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "c", importance: 5 });
+  store.setForget(saved.id, true);
+  const got = store.getById(saved.id);
+  // toRow maps SQLite 0/1 to boolean
+  assert.equal(got.forgotten, true);
+  store.close();
+});
+
+test("count excludes forgotten by default, includeForgotten opts in", () => {
+  const store = openMemory();
+  const a = store.save({ type: "project", title: "t1", content: "c" });
+  store.save({ type: "project", title: "t2", content: "c" });
+  store.save({ type: "preference", title: "p", content: "c" });
+  store.setForget(a.id, true);
+  assert.equal(store.count(), 2, "default excludes forgotten (matches list)");
+  assert.equal(store.count("project"), 1);
+  assert.equal(store.count("preference"), 1);
+  assert.equal(store.count(undefined, { includeForgotten: true }), 3);
+  assert.equal(store.count("project", { includeForgotten: true }), 2);
+  store.close();
+});
+
+test("search matches title, content and tags", () => {
+  const store = openMemory();
+  store.save({ type: "project", title: "记忆插件", content: "c1", tags: [] });
+  store.save({ type: "project", title: "t2", content: "用户用中文交流", tags: [] });
+  store.save({ type: "preference", title: "t3", content: "c3", tags: ["偏好"] });
+  assert.ok(store.search("记忆插件").some((m) => m.title === "记忆插件"));
+  assert.ok(store.search("中文").some((m) => m.content === "用户用中文交流"));
+  assert.ok(store.search("偏好").some((m) => m.tags.includes("偏好")));
+  store.close();
+});
+
+test("search with empty query returns []", () => {
+  const store = openMemory();
+  store.save({ type: "project", title: "t", content: "c" });
+  assert.deepEqual(store.search(""), []);
+  assert.deepEqual(store.search("   "), []);
+  store.close();
+});
+
+test("forgotten memories are excluded from list and search until un-forgotten", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "秘密", content: "c", importance: 5 });
+  assert.ok(store.list().some((m) => m.id === saved.id));
+  assert.ok(store.search("秘密").some((m) => m.id === saved.id));
+  store.setForget(saved.id, true);
+  assert.ok(!store.list().some((m) => m.id === saved.id));
+  assert.ok(!store.search("秘密").some((m) => m.id === saved.id));
+  store.setForget(saved.id, false);
+  assert.ok(store.list().some((m) => m.id === saved.id));
+  assert.ok(store.search("秘密").some((m) => m.id === saved.id));
+  store.close();
+});
+
+test("search matches CJK substring", () => {
+  const store = openMemory();
+  store.save({ type: "project", title: "t", content: "用户用中文交流" });
+  assert.equal(store.search("中文").length, 1);
+  store.close();
+});
+
+test("search respects limit", () => {
+  const store = openMemory();
+  for (let i = 0; i < 3; i++) store.save({ type: "project", title: `m${i}`, content: "匹配词" });
+  assert.equal(store.search("匹配词").length, 3);
+  assert.equal(store.search("匹配词", { limit: 2 }).length, 2);
+  store.close();
+});
+
+test("list sanitizes invalid limit/offset", () => {
+  const store = openMemory();
+  for (let i = 0; i < 3; i++) store.save({ type: "project", title: `t${i}`, content: "c" });
+  assert.equal(store.list({ limit: -1 }).length, 3);
+  assert.equal(store.list({ limit: 0 }).length, 3);
+  assert.equal(store.list({ limit: 1.5 }).length, 3);
+  assert.equal(store.list({ limit: 2, offset: -5 }).length, 2);
+  store.close();
+});
+
+test("schema migration adds archived column to legacy database", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-migrate-"));
+  const dbPath = join(dir, "legacy.db");
+  try {
+    // Create a legacy db WITHOUT archived column
+    const legacy = new DatabaseSync(dbPath);
+    legacy.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, source TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+    );`);
+    legacy.close();
+    // Open with createStore → should ALTER TABLE
+    const store = createStore(dbPath);
+    const cols = store.db.prepare("PRAGMA table_info(memories)").all().map((c) => c.name);
+    assert.ok(cols.includes("archived"), "archived column added");
+    store.close();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("setArchived marks entry archived; list excludes it by default", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "c", importance: 3 });
+  const archived = store.setArchived(saved.id, true);
+  assert.equal(archived.archived, true);
+  assert.equal(store.list().length, 0, "excluded from default list");
+  assert.equal(store.list({ includeArchived: true }).length, 1, "included with flag");
+  assert.equal(store.count(), 0, "excluded from default count");
+  assert.equal(store.count(undefined, { includeArchived: true }), 1);
+  store.close();
+});
+
+test("search excludes archived by default", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "secret", content: "hidden content", importance: 3 });
+  store.setArchived(saved.id, true);
+  assert.equal(store.search("secret").length, 0);
+  assert.equal(store.search("secret", { includeArchived: true }).length, 1);
+  store.close();
+});
+
+// --- vector search ---
+
+test("save/update persist embedding vector and searchVector ranks by cosine", () => {
+  const store = openMemory();
+  const a = store.save({ type: "preference", title: "猫", content: "喜欢猫", embedding: [1, 0, 0] });
+  const b = store.save({ type: "preference", title: "狗", content: "喜欢狗", embedding: [0, 1, 0] });
+  const c = store.save({ type: "preference", title: "猫狗", content: "都养", embedding: [0.9, 0.1, 0] });
+
+  const hits = store.searchVector([1, 0, 0], { limit: 3 });
+  assert.deepEqual(hits.map((m) => m.id), [a.id, c.id, b.id]);
+  assert.equal(hits[0].score, 1);
+  assert.ok(hits[1].score > hits[2].score);
+
+  // update re-stores embedding
+  store.update(b.id, { embedding: [1, 1, 0] });
+  const hits2 = store.searchVector([1, 1, 0], { limit: 3 });
+  assert.equal(hits2[0].id, b.id);
+  store.close();
+});
+
+test("searchVector only considers rows with an embedding and filters forgotten/archived", () => {
+  const store = openMemory();
+  const plain = store.save({ type: "project", title: "无向量", content: "x" });
+  const withVec = store.save({ type: "project", title: "有向量", content: "y", embedding: [1, 0, 0] });
+  store.setForget(withVec.id, true);
+  assert.deepEqual(store.searchVector([1, 0, 0]).map((m) => m.id), []);
+  store.setForget(withVec.id, false);
+  store.setArchived(withVec.id, true);
+  assert.deepEqual(store.searchVector([1, 0, 0]).map((m) => m.id), []);
+  store.setArchived(withVec.id, false);
+  assert.deepEqual(store.searchVector([1, 0, 0]).map((m) => m.id), [withVec.id]);
+  assert.equal(plain.id, plain.id, "plain row keeps id");
+  store.close();
+});
+
+test("setEmbedding, embeddedCount, needsEmbedding and threshold filtering", () => {
+  const store = openMemory();
+  const t1 = store.save({ type: "project", title: "t1", content: "c1" });
+  const m2 = store.save({ type: "project", title: "t2", content: "c2" });
+  assert.equal(store.embeddedCount(), 0);
+  store.setEmbedding(m2.id, [0, 1]);
+  assert.equal(store.embeddedCount(), 1);
+  const missing = store.needsEmbedding(10);
+  assert.equal(missing.length, 1);
+  assert.equal(missing[0].id, t1.id, "only the non-embedded row is listed");
+
+  const t3 = store.save({ type: "project", title: "t3", content: "c3", embedding: [1, 1] });
+  // threshold 0.99: only t3 (cos=1) survives; m2 ([0,1]) scores ~0.707.
+  const near = store.searchVector([1, 1], { limit: 5, threshold: 0.99 });
+  assert.deepEqual(near.map((m) => m.id), [t3.id]);
+  store.close();
+});
+
+test("save/update preserve archived flag", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "c" });
+  store.setArchived(saved.id, true);
+  const updated = store.update(saved.id, { content: "new" });
+  assert.equal(updated.archived, true, "update keeps archived");
+  store.close();
+});
+
+// --- compare-and-set update (item ①/③) ------------------------------------
+
+test("compareAndUpdate applies when the version token still matches", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "count=0" });
+  const before = store.getById(saved.id);
+  const updated = store.compareAndUpdate(saved.id, before.updated_at, { content: "count=1" });
+  assert.ok(updated, "CAS with the current version succeeds");
+  assert.equal(updated.content, "count=1");
+  assert.notEqual(updated.updated_at, before.updated_at, "version token advances");
+  store.close();
+});
+
+test("compareAndUpdate rejects a stale version token without writing", () => {
+  const store = openMemory();
+  const saved = store.save({ type: "project", title: "t", content: "count=0" });
+  const stale = store.getById(saved.id).updated_at;
+  store.update(saved.id, { content: "count=1" }); // concurrent write wins
+  const result = store.compareAndUpdate(saved.id, stale, { content: "count=2" });
+  assert.equal(result, undefined, "stale CAS is a miss");
+  assert.equal(store.getById(saved.id).content, "count=1", "no lost update");
+  store.close();
+});
+
+test("compareAndUpdate on unknown id throws like update", () => {
+  const store = openMemory();
+  assert.throws(() => store.compareAndUpdate("ghost", "any", { content: "x" }), /not found/);
+  store.close();
+});

package/test/stress.test.js

@@ -0,0 +1,209 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync } 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 { createDreamScheduler, parseReceipt } from "../src/dream.js";
+import { applyDecisions } from "../src/dream/decisions.js";
+import {
+  sessionDecisions,
+  arbitrationDecisions,
+  mockCtx
+} from "./helpers/dream-mock.js";
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  return { store, service, dream };
+}
+
+function tmpPath(prefix) {
+  return join(mkdtempSync(join(tmpdir(), prefix)), "memory.db");
+}
+
+// ---------------------------------------------------------------- 轴线 1
+
+test("long-session stress: Recall@k stays high, stale residual drops to zero", async () => {
+  const { store, service, dream } = setup();
+  const ctx = mockCtx({ onConsolidation: sessionDecisions });
+  const topics = 5;
+  const rounds = 3;
+
+  const gt = [];
+  for (let t = 1; t <= topics; t++) {
+    const title = `主题${String(t).padStart(2, "0")}`;
+    const { memory } = service.saveWithDedupe({ type: "project", title, content: `${title} 规范内容`, importance: 5 });
+    gt.push({ title, id: memory.id });
+  }
+  for (let r = 1; r <= rounds; r++) {
+    for (let t = 1; t <= topics; t++) {
+      service.saveWithDedupe({
+        type: "project",
+        title: `主题${String(t).padStart(2, "0")}·变体${r}`,
+        content: "旧变体",
+        importance: 3
+      });
+    }
+    const result = await dream.runDream(ctx, service, {});
+    assert.equal(result.ok, true);
+  }
+
+  let hits = 0;
+  for (const { title, id } of gt) {
+    if (service.search(title, { limit: 5 }).some((m) => m.id === id)) hits++;
+  }
+  assert.equal(hits, topics, "every canonical memory recalled in top-5 after 3 consolidation rounds");
+
+  const all = store.all();
+  const variants = all.filter((m) => m.type === "project" && m.title.includes("变体"));
+  assert.equal(variants.filter((m) => !m.archived).length, 0, "no stale variants remain active");
+  assert.equal(store.listDreamRuns().length, rounds, "every run written to the audit trail");
+  store.close();
+});
+
+// ---------------------------------------------------------------- 轴线 2
+
+test("arbitration set is replayable: deterministic, correct, idempotent replay", async () => {
+  const { store, service, dream } = setup();
+  const ctx = mockCtx({ onConsolidation: arbitrationDecisions });
+  const sets = [
+    { w: { type: "decision", title: "截止", content: "8月20日", importance: 5 }, l: { type: "decision", title: "截止(旧)", content: "8月15日", importance: 3 } },
+    { w: { type: "preference", title: "语言", content: "简体中文", importance: 5 }, l: { type: "preference", title: "语言(旧)", content: "繁体中文", importance: 2 } }
+  ];
+  for (const s of sets) {
+    service.saveWithDedupe({ ...s.l });
+    service.saveWithDedupe({ ...s.w });
+  }
+
+  const run = await dream.runDream(ctx, service, {});
+  assert.equal(run.ok, true);
+  assert.equal(run.applied, sets.length, "one conflict per arbitration set");
+
+  // correctness: winner kept (with provenance), loser archived
+  for (const s of sets) {
+    const winner = service.list({ type: s.w.type }).find((m) => m.title === s.w.title);
+    const loser = store.all().find((m) => m.title === s.l.title);
+    assert.ok(winner, "winner present");
+    assert.ok(loser?.archived, "loser archived");
+    assert.ok(winner.content.includes("已否决旧信息"), "provenance note appended");
+  }
+
+  // audit + receipt are replayable
+  const audit = store.getDreamRun(run.runId);
+  assert.equal(audit.status, "ok");
+  const receipt = parseReceipt(audit.receipt);
+  assert.equal(receipt.status, "ok");
+  assert.equal(Object.keys(audit.outcome.byId).length, sets.length * 2, "outcome covers every arbitrated id");
+  assert.equal(audit.decisions.length, sets.length, "raw decisions persisted");
+
+  // re-applying the recorded decision list is a no-op (idempotent replay)
+  assert.equal(applyDecisions(audit.decisions, service).applied, 0, "replay applies nothing");
+  store.close();
+});
+
+// ---------------------------------------------------------------- 轴线 3
+
+function bump(content) {
+  return `count=${Number(content.match(/count=(\d+)/)[1]) + 1}`;
+}
+
+test("concurrent agents: no duplicate merge, lost-update reproduced then fixed, crash recovery", () => {
+  const path = tmpPath("dsh-mneme-stress-test-");
+  const sA = createStore(path);
+  const svA = createService({ store: sA, mirror: null, config: {} });
+
+  // duplicate merge: 20 agents save the same title → exactly one active row
+  for (let i = 0; i < 20; i++) {
+    svA.saveWithDedupe({ type: "preference", title: "并发任务", content: `agent-${i}` });
+  }
+  assert.equal(
+    svA.list({ type: "preference", limit: 100 }).filter((m) => m.title === "并发任务").length,
+    1,
+    "no duplicate rows after concurrent same-title saves"
+  );
+
+  // lost update: two connections read the same baseline, then both write
+  const sB = createStore(path);
+  const svB = createService({ store: sB, mirror: null, config: {} });
+  svA.saveWithDedupe({ type: "history", title: "计数器", content: "count=0", importance: 3 });
+  const id = svA.list({ type: "history" })[0].id;
+
+  const readA = svA.getById(id).content; // count=0
+  const readB = svB.getById(id).content; // count=0 (stale)
+  svA.update(id, { content: bump(readA) }); // count=1
+  svB.update(id, { content: bump(readB) }); // count=1 → overwrites A's increment
+  assert.equal(svB.getById(id).content, "count=1", "unlocked read-modify-write loses an increment");
+
+  // serialized fix: re-read the latest value before writing
+  svA.update(id, { content: "count=0" });
+  svA.update(id, { content: bump(svA.getById(id).content) }); // reads 0 → 1
+  svB.update(id, { content: bump(svB.getById(id).content) }); // reads 1 → 2
+  assert.equal(svB.getById(id).content, "count=2", "re-read before write keeps both increments");
+
+  // crash recovery: committed writes survive an exception and a reopen
+  svA.saveWithDedupe({ type: "project", title: "已提交", content: "x" });
+  assert.throws(() => svA.update("ghost", { content: "boom" }), /not found/, "unknown-id update throws");
+  sA.close();
+  sB.close();
+
+  const sR = createStore(path);
+  assert.ok(sR.getById(id), "counter survives reopen");
+  assert.ok(sR.all().some((m) => m.title === "已提交"), "committed write survives reopen");
+  assert.equal(sR.all().filter((m) => m.title === "已提交").length, 1, "no partial residue");
+  sR.close();
+});
+
+// ---------------------------------------------------------------- CAS + atomicity (item ③)
+
+test("CAS concurrent increments: stale version rejected, retry lands both increments", () => {
+  const path = tmpPath("dsh-mneme-stress-cas-");
+  const sA = createStore(path);
+  const svA = createService({ store: sA, mirror: null, config: {} });
+  const sB = createStore(path);
+  const svB = createService({ store: sB, mirror: null, config: {} });
+
+  svA.saveWithDedupe({ type: "history", title: "计数器", content: "count=0", importance: 3 });
+  const id = svA.list({ type: "history" })[0].id;
+  svA.update(id, { content: "count=0" });
+  const baseline = svA.getById(id); // updated_at=T, count=0
+
+  const aOk = svA.compareAndUpdate(id, baseline.updated_at, { content: bump("count=0") });
+  assert.ok(aOk, "current-version CAS lands");
+  const bStale = svB.compareAndUpdate(id, baseline.updated_at, { content: bump("count=0") });
+  assert.equal(bStale, undefined, "stale-version CAS rejected — no lost update");
+
+  const cur = svB.getById(id);
+  svB.compareAndUpdate(id, cur.updated_at, { content: bump(cur.content) });
+  assert.equal(svB.getById(id).content, "count=2", "re-read + retry keeps both increments");
+  sA.close();
+  sB.close();
+});
+
+test("multi-step transaction is atomic: a mid-way throw rolls back every step", () => {
+  const path = tmpPath("dsh-mneme-stress-atomic-");
+  const s = createStore(path);
+  const sv = createService({ store: s, mirror: null, config: {} });
+
+  assert.throws(
+    () => sv.transaction(() => {
+      sv.saveWithDedupe({ type: "project", title: "原子A", content: "x" });
+      sv.saveWithDedupe({ type: "project", title: "原子B", content: "y" });
+      throw new Error("boom");
+    }),
+    /boom/
+  );
+  assert.ok(!s.all().some((m) => m.title === "原子A"), "atomicA fully rolled back");
+  assert.ok(!s.all().some((m) => m.title === "原子B"), "atomicB fully rolled back");
+
+  // a clean transaction commits both steps
+  sv.transaction(() => {
+    sv.saveWithDedupe({ type: "project", title: "完整A", content: "x" });
+    sv.saveWithDedupe({ type: "project", title: "完整B", content: "y" });
+  });
+  assert.equal(s.all().filter((m) => m.title === "完整A").length, 1, "committed step A");
+  assert.equal(s.all().filter((m) => m.title === "完整B").length, 1, "committed step B");
+  s.close();
+});

package/test/summarize.test.js

@@ -0,0 +1,156 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSummarizer, parseSummaryJson } from "../src/summarize.js";
+
+function setup(over = {}, opts = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const events = [];
+  const calls = [];
+  const ctx = {
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {
+        const i = events.findIndex((e) => e.name === name && e.fn === fn);
+        if (i !== -1) events.splice(i, 1);
+      };
+    },
+    llm: {
+      stream(options) {
+        calls.push(options);
+        if (opts.stream) return opts.stream(options);
+        const json = JSON.stringify([
+          { type: "decision", title: "选型", content: "确定用 node:sqlite", importance: 4 },
+          { type: "preference", title: "语言", content: "用户喜欢中文交流", importance: 5 }
+        ]);
+        return (async function* () {
+          yield { type: "block-start", block: { type: "text" } };
+          yield { type: "text-delta", delta: json };
+          yield { type: "block-end", block: { type: "text" } };
+          yield { type: "finish", kind: "ok" };
+        })();
+      }
+    }
+  };
+  const config = { autoSummarize: true, ...over };
+  const summarizer = createSummarizer(ctx, service, config);
+  return { store, service, events, calls, summarizer };
+}
+
+// A realistic direct human prompt event (source.kind === "user").
+function userMessage(text) {
+  return {
+    type: "user/message",
+    data: { source: { kind: "user" }, content: [{ type: "text", text }] }
+  };
+}
+
+test("parseSummaryJson extracts valid entries and skips malformed ones", () => {
+  const parsed = parseSummaryJson(`前导文字 {"a":1}
+  [
+    {"type":"decision","title":"t1","content":"c1","importance":4},
+    {"type":"nonsense","title":"bad","content":"x"},
+    "garbage",
+    {"type":"preference","title":"t2","content":"c2","importance":2}
+  ]`);
+  assert.equal(parsed.length, 2);
+  assert.equal(parsed[0].type, "decision");
+  assert.equal(parsed[1].type, "preference");
+});
+
+test("subscribes to session/event when autoSummarize enabled", () => {
+  const { events } = setup();
+  assert.ok(events.some((e) => e.name === "session/event"));
+});
+
+test("does not subscribe when autoSummarize disabled", () => {
+  const { events } = setup({ autoSummarize: false });
+  assert.ok(!events.some((e) => e.name === "session/event"));
+});
+
+test("turn/end event triggers summarization and stores entries", async () => {
+  const { events, store } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s1",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("帮我选型"), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(store.count(), 2);
+  const all = store.all();
+  assert.ok(all.some((m) => m.type === "decision"));
+  assert.ok(all.some((m) => m.type === "preference"));
+});
+
+test("skips summarization for events other than turn/end", async () => {
+  const { events, store, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = { id: "s1", requestHeader: () => ({ config: {} }), events: [] };
+  await handler(session, { seq: 1, type: "user/message" });
+  assert.equal(store.count(), 0);
+  assert.equal(calls.length, 0);
+});
+
+test("dispose unsubscribes and stops later turn/end events from summarizing", async () => {
+  const { events, summarizer, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  summarizer.dispose();
+  // The ctx.on() disposer must have removed the listener.
+  assert.ok(!events.some((e) => e.name === "session/event"));
+  const session = {
+    id: "s1",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("你好"), { seq: 2, type: "turn/end" }]
+  };
+  // Even a stale handler reference must not start a new LLM call.
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 0);
+});
+
+test("excludes plugin-injected user/message events from summarization input", async () => {
+  const { events, store, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s2",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      {
+        seq: 1,
+        type: "user/message",
+        data: { source: { kind: "plugin" }, content: [{ type: "text", text: "AGENTS.md 内容" }] }
+      },
+      userMessage("帮我看看这个报错"),
+      { seq: 3, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 3, type: "turn/end" });
+  assert.equal(calls.length, 1);
+  const userMessages = calls[0].messages.filter((m) => m.role === "user");
+  assert.equal(userMessages.length, 1);
+  assert.ok(!JSON.stringify(calls[0].messages).includes("AGENTS.md"));
+  assert.equal(store.count(), 2);
+});
+
+test("aborted finish does not store entries", async () => {
+  const { events, store, calls } = setup({}, {
+    stream() {
+      return (async function* () {
+        yield { type: "block-start", block: { type: "text" } };
+        yield { type: "text-delta", delta: "[]" };
+        yield { type: "finish", kind: "aborted" };
+      })();
+    }
+  });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s3",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("继续"), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1); // the stream was actually reached
+  assert.equal(store.count(), 0);
+});