@modusensus/dsh-mneme 0.2.4 → 0.2.5

package/test/api.test.js

@@ -0,0 +1,385 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path, method = "GET", body = null) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = method;
+  r.headers = {};
+  if (body !== null) {
+    process.nextTick(() => {
+      r.emit("data", Buffer.from(JSON.stringify(body)));
+      r.emit("end");
+    });
+  }
+  return r;
+}
+
+function setup(embedder, apiToken = "") {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const commands = {
+    add: (def) => settings.addCommand(def),
+    remove: (id) => settings.removeCommand(id),
+    list: () => settings.listCommands()
+  };
+  const routes = [];
+  const ctx = {
+    webServer: {
+      register(route) {
+        routes.push(route);
+        return () => {};
+      }
+    }
+  };
+  const api = createApi(ctx, service, settings, commands, embedder, undefined, apiToken);
+  return { store, service, routes, api, settings, apiToken };
+}
+
+function findHandler(routes, path) {
+  const route = routes.find((r) => r.path === path || (r.kind === "prefix" && path.startsWith(r.path)));
+  return route;
+}
+
+test("registers list, search, and get prefix routes", () => {
+  const { routes } = setup();
+  const paths = routes.map((r) => r.path);
+  assert.ok(paths.includes("/api/dsh-mneme/list"));
+  assert.ok(paths.includes("/api/dsh-mneme/search"));
+  assert.ok(paths.includes("/api/dsh-mneme"));
+});
+
+test("GET /api/dsh-mneme/list returns memories as JSON", async () => {
+  const { routes, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list?type=preference"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.items.length, 1);
+  assert.equal(data.items[0].title, "语言");
+});
+
+test("GET /api/dsh-mneme/search?q= returns matches", async () => {
+  const { routes, service } = setup();
+  service.saveWithDedupe({ type: "project", title: "记忆插件", content: "SQLite 中文搜索" });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/search");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/search?q=%E4%B8%AD%E6%96%87"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.items.length, 1);
+});
+
+test("unknown route under prefix returns 404 json", async () => {
+  const { routes } = setup();
+  const route = findHandler(routes, "/api/dsh-mneme");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/nope"), res);
+  assert.equal(res.statusCode, 404);
+});
+
+test("list total excludes forgotten entries", async () => {
+  const { routes, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "正常", content: "可见" });
+  const forgotten = service.saveWithDedupe({ type: "preference", title: "遗忘", content: "隐藏" });
+  service.saveWithDedupe({ type: "project", title: "项目", content: "其他类型" });
+  service.setForget(forgotten.memory.id, true);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list?type=preference"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.items.length, 1);
+  assert.equal(data.total, 1, "total matches visible items, forgotten excluded");
+});
+
+test("list honors limit/offset", async () => {
+  const { routes, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "a", content: "1" });
+  service.saveWithDedupe({ type: "preference", title: "b", content: "2" });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list?limit=1&offset=0"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.items.length, 1);
+  assert.equal(data.total, 2);
+});
+
+test("responses carry application/json content-type", async () => {
+  const { routes } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list"), res);
+  assert.match(res.headers["Content-Type"], /application\/json/);
+});
+
+test("handler errors return 500 json instead of leaking to host", async () => {
+  const routes = [];
+  const ctx = {
+    webServer: {
+      register(route) {
+        routes.push(route);
+        return () => {};
+      }
+    }
+  };
+  const service = {
+    list() { throw new Error("boom"); },
+    count() { throw new Error("boom"); },
+    search() { throw new Error("boom"); },
+    toApiList() { return []; }
+  };
+  createApi(ctx, service, {}, { add: () => { throw new Error("x"); }, remove: () => false, list: () => [] });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list"), res);
+  assert.equal(res.statusCode, 500);
+  assert.deepEqual(JSON.parse(res.body), { error: "internal" });
+});
+
+test("GET /api/dsh-mneme/profile returns stored profile", async () => {
+  const { routes, settings } = setup();
+  settings.setProfile("我是前端");
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/profile");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/profile"), res);
+  assert.equal(res.statusCode, 200);
+  assert.equal(JSON.parse(res.body).profile, "我是前端");
+});
+
+test("PUT /api/dsh-mneme/profile saves profile", async () => {
+  const { routes, settings } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/profile");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/profile", "PUT", { profile: "新画像" }), res);
+  assert.equal(res.statusCode, 200);
+  assert.equal(JSON.parse(res.body).profile, "新画像");
+  assert.equal(settings.getProfile(), "新画像");
+});
+
+test("GET /api/dsh-mneme/rules returns stored rules", async () => {
+  const { routes, settings } = setup();
+  settings.setRules(["规则1", "规则2"]);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/rules");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/rules"), res);
+  assert.equal(res.statusCode, 200);
+  assert.deepEqual(JSON.parse(res.body).rules, ["规则1", "规则2"]);
+});
+
+test("PUT /api/dsh-mneme/rules saves rules", async () => {
+  const { routes, settings } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/rules");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/rules", "PUT", { rules: ["a", "b"] }), res);
+  assert.equal(res.statusCode, 200);
+  assert.deepEqual(settings.getRules(), ["a", "b"]);
+});
+
+test("GET /api/dsh-mneme/commands lists commands", async () => {
+  const { routes, settings } = setup();
+  settings.addCommand({ name: "agenda", instruction: "x" });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/commands");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/commands"), res);
+  assert.equal(res.statusCode, 200);
+  assert.equal(JSON.parse(res.body).commands.length, 1);
+});
+
+test("POST /api/dsh-mneme/commands adds a command; DELETE removes", async () => {
+  const { routes } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/commands");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/commands", "POST", { name: "fmt", description: "d", instruction: "格式化" }), res);
+  assert.equal(res.statusCode, 200);
+  const { command } = JSON.parse(res.body);
+  assert.equal(command.name, "fmt");
+  const del = new FakeRes();
+  await route.handler(req(`/api/dsh-mneme/commands?id=${command.id}`, "DELETE"), del);
+  assert.equal(JSON.parse(del.body).removed, true);
+});
+
+test("POST /api/dsh-mneme/commands rejects invalid name with 400", async () => {
+  const { routes } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/commands");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/commands", "POST", { name: "Bad Name", instruction: "x" }), res);
+  assert.equal(res.statusCode, 400);
+});
+
+// --- vector search routes ---
+
+function setupWithEmbedder(embedder) {
+  const base = setup(embedder);
+  base.settings.setVectorConfig({
+    enabled: true,
+    baseUrl: "https://api.example.com/v1",
+    apiKey: "sk-test",
+    model: "text-embedding-v3"
+  });
+  return base;
+}
+
+test("vector-config defaults and round-trips through PUT/GET", async () => {
+  const { routes, settings } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/vector-config");
+
+  const get1 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/vector-config"), get1);
+  assert.equal(JSON.parse(get1.body).config.enabled, false);
+
+  const put = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/vector-config", "PUT", { enabled: true, baseUrl: "https://api.openai.com/v1", apiKey: "sk-x", model: "text-embedding-3-small" }), put);
+  assert.equal(JSON.parse(put.body).config.model, "text-embedding-3-small");
+  assert.equal(settings.getVectorConfig().enabled, true);
+});
+
+test("search mode=vector merges vector results when embedder returns a vector", async () => {
+  const embedder = {
+    embed: async () => [1, 0, 0],
+    reindexMissing: async () => ({ indexed: 0, skipped: 0 })
+  };
+  const { routes, store, service } = setupWithEmbedder(embedder);
+  const v = service.saveWithDedupe({ type: "preference", title: "猫", content: "喜欢猫" });
+  store.setEmbedding(v.memory.id, [1, 0, 0]);
+  service.saveWithDedupe({ type: "preference", title: "狗", content: "喜欢狗" });
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/search");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/search?q=%E7%8C%AB&mode=vector"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.mode, "vector");
+  assert.equal(data.items.length, 1, "keyword hit + vector fill merged");
+  assert.equal(data.items[0].title, "猫");
+});
+
+test("search falls back to keyword when embedder disabled or unavailable", async () => {
+  // embedder that resolves null (disabled provider)
+  const embedder = { embed: async () => null, reindexMissing: async () => ({ indexed: 0, skipped: 0 }) };
+  const { routes, service } = setupWithEmbedder(embedder);
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文交流" });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/search");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/search?q=%E4%B8%AD%E6%96%87"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.mode, "keyword");
+  assert.equal(data.items.length, 1);
+});
+
+test("vector-reindex calls embedder and returns counts", async () => {
+  const embedder = { reindexMissing: async () => ({ indexed: 2, skipped: 1 }) };
+  const { routes } = setupWithEmbedder(embedder);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/vector-reindex");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/vector-reindex"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.indexed, 2);
+  assert.equal(data.skipped, 1);
+});
+
+test("vector-config masks apiKey; empty/masked key on PUT keeps existing", async () => {
+  const { routes, settings } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/vector-config");
+
+  // PUT stores the real key but responds masked
+  const put = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/vector-config", "PUT", {
+    enabled: true, baseUrl: "https://api.openai.com/v1", apiKey: "sk-abcdefghijklmnop", model: "m1"
+  }), put);
+  const putBody = JSON.parse(put.body);
+  assert.equal(putBody.config.apiKey, "sk-***mnop", "PUT response masked");
+  assert.equal(settings.getVectorConfig().apiKey, "sk-abcdefghijklmnop", "storage keeps the real key");
+
+  // GET returns masked key, other fields intact
+  const get = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/vector-config"), get);
+  const getBody = JSON.parse(get.body);
+  assert.equal(getBody.config.apiKey, "sk-***mnop");
+  assert.equal(getBody.config.baseUrl, "https://api.openai.com/v1");
+  assert.equal(getBody.config.enabled, true);
+
+  // PUT with empty apiKey keeps the previous key
+  const put2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/vector-config", "PUT", {
+    enabled: true, baseUrl: "https://api.openai.com/v1", apiKey: "", model: "m2"
+  }), put2);
+  assert.equal(settings.getVectorConfig().apiKey, "sk-abcdefghijklmnop", "empty key keeps existing");
+  assert.equal(JSON.parse(put2.body).config.model, "m2");
+
+  // PUT with a masked apiKey (client round-trip) also keeps the previous key
+  const put3 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/vector-config", "PUT", {
+    enabled: true, baseUrl: "https://api.openai.com/v1", apiKey: "sk-***mnop", model: "m3"
+  }), put3);
+  assert.equal(settings.getVectorConfig().apiKey, "sk-abcdefghijklmnop", "masked key keeps existing");
+});
+
+test("apiToken protects write/secret endpoints while read endpoints stay open", async () => {
+  const { routes } = setup(undefined, "secret-token");
+  const list = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const profile = routes.find((r) => r.path === "/api/dsh-mneme/profile");
+  const vec = routes.find((r) => r.path === "/api/dsh-mneme/vector-config");
+  const reindex = routes.find((r) => r.path === "/api/dsh-mneme/vector-reindex");
+
+  // read-only endpoint stays open without a token
+  const resList = new FakeRes();
+  await list.handler(req("/api/dsh-mneme/list"), resList);
+  assert.equal(resList.statusCode, 200, "list stays open");
+
+  // secret endpoint without token → 401
+  const resVec = new FakeRes();
+  await vec.handler(req("/api/dsh-mneme/vector-config"), resVec);
+  assert.equal(resVec.statusCode, 401, "vector-config GET requires token");
+
+  // write endpoint without token → 401
+  const resProfile = new FakeRes();
+  await profile.handler(req("/api/dsh-mneme/profile", "PUT", { profile: "x" }), resProfile);
+  assert.equal(resProfile.statusCode, 401, "profile PUT requires token");
+
+  // reindex without token → 401
+  const resReindex = new FakeRes();
+  await reindex.handler(req("/api/dsh-mneme/vector-reindex"), resReindex);
+  assert.equal(resReindex.statusCode, 401, "vector-reindex requires token");
+
+  // with a Bearer token everything is allowed
+  const authReq = (path, method = "GET", body = null) => {
+    const r = req(path, method, body);
+    r.headers = { authorization: "Bearer secret-token" };
+    return r;
+  };
+  const resVecOk = new FakeRes();
+  await vec.handler(authReq("/api/dsh-mneme/vector-config"), resVecOk);
+  assert.equal(resVecOk.statusCode, 200, "vector-config GET with token");
+  const resProfileOk = new FakeRes();
+  await profile.handler(authReq("/api/dsh-mneme/profile", "PUT", { profile: "hi" }), resProfileOk);
+  assert.equal(resProfileOk.statusCode, 200, "profile PUT with token");
+
+  // wrong token → 401
+  const bad = req("/api/dsh-mneme/vector-config");
+  bad.headers = { authorization: "Bearer wrong" };
+  const resBad = new FakeRes();
+  await vec.handler(bad, resBad);
+  assert.equal(resBad.statusCode, 401, "wrong token rejected");
+});
+
+test("no apiToken configured keeps all endpoints open", async () => {
+  const { routes } = setup();
+  const vec = routes.find((r) => r.path === "/api/dsh-mneme/vector-config");
+  const res = new FakeRes();
+  await vec.handler(req("/api/dsh-mneme/vector-config"), res);
+  assert.equal(res.statusCode, 200, "open when apiToken is unset");
+});

package/test/audit.test.js

@@ -0,0 +1,290 @@
+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 {
+  createDreamScheduler,
+  hashSnapshot,
+  buildReceipt,
+  parseReceipt,
+  buildOutcome
+} from "../src/dream.js";
+import { applyDecisions } from "../src/dream/decisions.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// ---------------------------------------------------------------- helpers
+
+/**
+ * Minimal DSH-like ctx whose LLM distinguishes the two dream calls by the user
+ * prompt shape: consolidation prompts start with "id=…", summary prompts with
+ * "- title: content". `onConsolidation` receives the raw list text and returns
+ * a decisions JSON string; `summaryText` (or a throw) drives the summary call.
+ */
+function mockCtx({ onConsolidation, summaryText = "记忆库总览：用户偏好中文。" } = {}) {
+  return {
+    logger: { warn: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          yield { type: "block-start", index: 0, blockType: "text" };
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+          yield { type: "block-end", index: 0, block: { type: "text" } };
+          yield { type: "finish", reason: { kind: "stop" } };
+          return;
+        }
+        if (typeof summaryText === "string") {
+          yield { type: "text-delta", index: 0, text: summaryText };
+          yield { type: "finish", reason: { kind: "stop" } };
+        } else {
+          throw summaryText instanceof Error ? summaryText : new Error(String(summaryText));
+        }
+      }
+    }
+  };
+}
+
+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 };
+}
+
+// ---------------------------------------------------------------- audit rows
+
+test("successful runDream writes an audit row with receipt, decisions and outcome", async () => {
+  const { store, service, dream } = setup();
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const ctx = mockCtx({
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "插件总览", content: "合并内容", importance: 4 }
+    ])
+  });
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, true);
+  assert.equal(result.applied, 1);
+
+  const runs = store.listDreamRuns();
+  assert.equal(runs.length, 1);
+  const run = runs[0];
+  assert.equal(run.status, "ok");
+  assert.equal(run.input_count, 2);
+  assert.equal(run.applied, 1);
+  assert.equal(run.summary_stored, true);
+  assert.equal(run.provider, "mock");
+  assert.match(run.receipt, /^dsh-mneme:run:/);
+
+  // receipt round-trips and correlates with the audit row
+  const parsed = parseReceipt(run.receipt);
+  assert.deepEqual(parsed, {
+    runId: run.id,
+    status: "ok",
+    snapshotHash: run.snapshot_hash.slice(0, 12),
+    inputCount: 2,
+    applied: 1,
+    summaryStored: true
+  });
+
+  // per-id outcome is derived correctly
+  assert.equal(run.outcome.byId[a.id], "merge-archived");
+  assert.equal(run.outcome.byId[b.id], "merge-keep");
+  // raw decisions are stored for replay
+  assert.equal(run.decisions.length, 1);
+  assert.equal(run.decisions[0].action, "merge");
+  // full input snapshot is persisted and its digest matches — the audit row
+  // alone can rebuild the exact arbitration input offline
+  assert.equal(run.input.length, 2);
+  assert.deepEqual(run.input.map((m) => m.title).sort(), ["插件", "插件2"]);
+  assert.equal(hashSnapshot(run.input), run.snapshot_hash, "input snapshot digest matches stored snapshot_hash");
+  store.close();
+});
+
+test("failed runDream records status failed with the error", async () => {
+  const { store, service, dream } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const ctx = mockCtx({ onConsolidation: () => "抱歉，我无法处理这个任务" });
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, false);
+  assert.match(result.error, /no json array/);
+
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.status, "failed");
+  assert.equal(run.decisions, undefined);
+  assert.match(run.error, /no json array/);
+  const parsed = parseReceipt(run.receipt);
+  assert.equal(parsed.status, "failed");
+  store.close();
+});
+
+test("summary failure still records the applied decisions for replay", async () => {
+  const { store, service, dream } = setup();
+  const { memory: m } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const ctx = mockCtx({
+    onConsolidation: () => JSON.stringify([{ action: "keep", ids: [m.id] }]),
+    summaryText: new Error("summary boom")
+  });
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, false);
+  assert.equal(result.error, "llm failed");
+
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.status, "failed");
+  assert.equal(run.decisions.length, 1, "decisions captured despite summary failure");
+  assert.equal(run.outcome.byId[m.id], "keep");
+  store.close();
+});
+
+test("audit rows persist across store reopen (file-backed)", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-audit-"));
+  const path = join(dir, "memory.db");
+  const s1 = createStore(path);
+  s1.saveDreamRun({
+    id: "run-1", status: "ok", snapshot_hash: "abc", input_count: 1,
+    decisions: [{ action: "keep", ids: ["x"] }],
+    outcome: { byId: { x: "keep" } }, applied: 0, summary_stored: false,
+    receipt: "dsh-mneme:run:run-1:ok:abc:1:0:0"
+  });
+  s1.close();
+  const s2 = createStore(path);
+  const run = s2.getDreamRun("run-1");
+  assert.equal(run.status, "ok");
+  assert.equal(run.decisions[0].action, "keep");
+  s2.close();
+});
+
+// ---------------------------------------------------------------- hashing & receipts
+
+test("hashSnapshot is deterministic and order-independent", () => {
+  const mk = (id, title, content = "c") => ({ id, type: "project", title, content, importance: 3, updated_at: "2026-01-01T00:00:00.000Z" });
+  const a = mk("a", "t1");
+  const b = mk("b", "t2");
+  assert.equal(hashSnapshot([a, b]), hashSnapshot([b, a]), "order independent");
+  assert.equal(hashSnapshot([a, b]), hashSnapshot([{ ...a }, { ...b }]), "field order / clone independent");
+  assert.notEqual(hashSnapshot([a, b]), hashSnapshot([a, { ...b, content: "changed" }]), "content change flips hash");
+});
+
+test("receipt round-trips and malformed receipts parse to undefined", () => {
+  const receipt = buildReceipt({ runId: "r1", status: "ok", snapshotHash: "0123456789abcdef", inputCount: 3, applied: 2, summaryStored: true });
+  assert.deepEqual(parseReceipt(receipt), { runId: "r1", status: "ok", snapshotHash: "0123456789ab", inputCount: 3, applied: 2, summaryStored: true });
+  for (const bad of ["nope", "", "dsh-mneme:run:r1", "dsh-mneme:run:r1:weird:abc:1:0:0", "dsh-mneme:run:r1:ok:abc:nan:0:0"]) {
+    assert.equal(parseReceipt(bad), undefined, `rejects ${JSON.stringify(bad)}`);
+  }
+});
+
+test("buildOutcome maps every decision action to per-id disposition", () => {
+  const outcome = buildOutcome([
+    { action: "keep", ids: ["k"] },
+    { action: "archive", ids: ["a1", "a2"] },
+    { action: "merge", ids: ["m1", "m2"], keepSource: "m1" },
+    { action: "conflict", winner: "w", loser: "l" }
+  ]);
+  assert.equal(outcome.byId.k, "keep");
+  assert.equal(outcome.byId.a1, "archived");
+  assert.equal(outcome.byId.a2, "archived");
+  assert.equal(outcome.byId.m1, "merge-keep");
+  assert.equal(outcome.byId.m2, "merge-archived");
+  assert.equal(outcome.byId.w, "conflict-winner");
+  assert.equal(outcome.byId.l, "conflict-archived");
+});
+
+// ---------------------------------------------------------------- replayability
+
+test("replaying a recorded decision list is idempotent", async () => {
+  const { store, service, dream } = setup();
+  const { memory: a } = service.saveWithDedupe({ type: "decision", title: "截止", content: "8月15日", importance: 4 });
+  const { memory: b } = service.saveWithDedupe({ type: "decision", title: "截止新", content: "8月20日", importance: 5 });
+  const ctx = mockCtx({
+    onConsolidation: () => JSON.stringify([{ action: "conflict", winner: b.id, loser: a.id, reason: "更新" }])
+  });
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, true);
+
+  const run = store.getDreamRun(result.runId);
+  assert.equal(run.decisions[0].winner, b.id);
+  assert.equal(run.outcome.byId[a.id], "conflict-archived");
+  assert.equal(run.outcome.byId[b.id], "conflict-winner");
+
+  // store already reflects the run
+  assert.equal(store.getById(a.id).archived, true);
+  assert.ok(store.getById(b.id).content.includes("已否决旧信息"), "provenance note appended");
+
+  // replay the exact recorded decision list → no-op (idempotent)
+  const replayed = applyDecisions(run.decisions, service);
+  assert.equal(replayed.applied, 0, "already-applied decisions re-apply nothing");
+  assert.equal(store.getById(a.id).archived, true);
+  assert.equal(store.getById(b.id).content, store.getById(b.id).content);
+  store.close();
+});
+
+test("re-applying a decision many times has no cumulative side effects", async () => {
+  const { store, service, dream } = setup();
+  const { memory: a } = service.saveWithDedupe({ type: "decision", title: "截止", content: "8月15日", importance: 4 });
+  const { memory: b } = service.saveWithDedupe({ type: "decision", title: "截止新", content: "8月20日", importance: 5 });
+  const { memory: m1 } = service.saveWithDedupe({ type: "project", title: "甲", content: "旧甲", importance: 3 });
+  const { memory: m2 } = service.saveWithDedupe({ type: "project", title: "乙", content: "旧乙", importance: 4 });
+  const decisions = [
+    { action: "conflict", winner: b.id, loser: a.id, reason: "更新" },
+    { action: "merge", ids: [m1.id, m2.id], keepSource: m2.id, title: "甲乙", content: "合并", importance: 4 }
+  ];
+  // apply 3 times (e.g. concurrent/replayed dream runs)
+  for (let i = 0; i < 3; i++) applyDecisions(decisions, service);
+
+  const winner = store.getById(b.id);
+  assert.equal(winner.content.split("已否决旧信息").length - 1, 1, "provenance note appended exactly once");
+  assert.equal(store.getById(a.id).archived, true);
+  assert.equal(store.getById(m2.id).title, "甲乙", "keeper merged");
+  assert.equal(store.getById(m1.id).archived, true, "merge source archived once");
+  store.close();
+});
+
+// ---------------------------------------------------------------- reconcile (item ②)
+
+test("runDream records status reconcile, not a fake ok, when a target changed during the run", async () => {
+  const { store, service, dream } = setup();
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "旧", content: "A", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "新", content: "B", importance: 4 });
+  // The "LLM call" mutates a target while producing the decision list —
+  // simulating a concurrent human/agent edit inside the run window.
+  const ctx = mockCtx({
+    onConsolidation: () => {
+      service.update(b.id, { content: "并发编辑" });
+      return JSON.stringify([
+        { action: "merge", ids: [a.id, b.id], title: "合并", content: "合并内容", importance: 4, keepSource: b.id }
+      ]);
+    }
+  });
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, false, "partial commit is not ok");
+  assert.equal(result.status, "reconcile", "explicit reconcile status");
+  assert.equal(result.applied, 0, "conflicting merge not applied");
+
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.status, "reconcile", "audit row records reconcile");
+  assert.equal(run.applied, 0);
+  const parsed = parseReceipt(run.receipt);
+  assert.equal(parsed.status, "reconcile", "receipt records reconcile, never ok");
+  assert.equal(parsed.applied, 0);
+  // outcome is derived from what actually committed: the merge is NOT claimed
+  assert.equal(run.outcome.byId[b.id], undefined, "keeper not claimed as merge-keep");
+  assert.equal(run.outcome.byId[a.id], undefined, "source not claimed as merge-archived");
+  assert.equal(run.outcome.conflicts.length, 1, "conflict recorded in the audit row");
+  // the concurrent edit survived
+  assert.equal(store.getById(b.id).content, "并发编辑");
+  store.close();
+});
+
+test("buildOutcome over actually-committed sub-steps never claims a rolled-back merge", () => {
+  const committed = [
+    { action: "keep", ids: ["k"] },
+    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c" }
+  ];
+  const outcome = buildOutcome(committed);
+  assert.equal(outcome.byId.m1, "merge-keep");
+  assert.equal(outcome.byId.m2, "merge-archived");
+  assert.equal(outcome.byId.k, "keep");
+});