@modusensus/dsh-mneme 0.7.9 → 0.7.11

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

@@ -45,14 +45,6 @@ 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: {} });
@@ -181,7 +173,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, demotionConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, baseConfig(), 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");
@@ -196,7 +188,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, demotionConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
   const after = service.getById(m.id);
   assert.equal(result.status, "ok");
   assert.equal(after.archived, true, "past compress days → archived");
@@ -283,7 +275,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, demotionConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, baseConfig(), 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");
@@ -297,7 +289,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, demotionConfig(), ctx.logger, null, null);
+  const result = await runSleep(ctx, service, baseConfig(), 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");
@@ -371,162 +363,3 @@ test("sleep: runSleep is abortable via signal between phases", async () => {
   assert.equal(result.phases.conflicts, undefined, "aborted before any phase ran");
   store.close();
 });
-
-// ------------------------------------------------ entity extraction (issue #23)
-
-// Write-path extractor is gated on entityExtractionEnabled (default off), so
-// default installs never accumulate entities → ego-graph panel blank. This
-// sleep phase backfills it; these tests cover gating, idempotence and
-// fail-safe batching.
-const ENTITY_LLM_JSON = JSON.stringify({
-  entities: [{ name: "X", type: "concept", attrs: [{ key: "k", value: "v" }] }],
-  relations: []
-});
-
-test("sleep: entity extraction skips when disabled", async () => {
-  const { service, store } = setup();
-  makeMemory(service, "记忆A", "内容A", "history");
-  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
-  const result = await runSleep(
-    ctx, service,
-    baseConfig({ sleepEntityExtractionEnabled: false }),
-    ctx.logger, null, null
-  );
-  assert.equal(result.phases["entity-extraction"].status, "skipped", "disabled → skipped");
-  store.close();
-});
-
-test("sleep: extracted memories are stamped and not re-extracted", async () => {
-  const { service, store } = setup();
-  const mem = makeMemory(service, "记忆B", "内容B", "history");
-  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
-  const config = baseConfig({ sleepEntityExtractionEnabled: true });
-  // First cycle backfills → memory gets entity_extracted_at stamped.
-  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(first.phases["entity-extraction"].status, "ok", "first cycle extracts");
-  assert.ok(service.getById(mem.id).metadata?.entity_extracted_at, "stamp written");
-  // Second cycle has nothing un-stamped left → skipped.
-  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(second.phases["entity-extraction"].status, "skipped", "nothing left to extract");
-  store.close();
-});
-
-test("sleep: entity-less extracts are stamped so they are not re-queued forever", async () => {
-  const { service, store } = setup();
-  const mem = makeMemory(service, "无实体记忆", "这里没有任何实体", "history");
-  // LLM legitimately returns no entities — must still be stamped, else every
-  // sleep cycle re-extracts the same text forever (issue #23 regression).
-  const ctx = mockCtx(() => JSON.stringify({ entities: [], relations: [] }), { provider: "p", model: "m" });
-  const config = baseConfig({ sleepEntityExtractionEnabled: true });
-  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(first.phases["entity-extraction"].status, "ok", "empty extract counts as handled");
-  assert.equal(first.phases["entity-extraction"].extracted, 1);
-  assert.ok(service.getById(mem.id).metadata?.entity_extracted_at, "stamp written even with no entities");
-  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(second.phases["entity-extraction"].status, "skipped", "stamped → not re-queued");
-  store.close();
-});
-
-test("sleep: entity extraction backfills entities for un-extracted memories", async () => {
-  const { service, store } = setup();
-  const mem = makeMemory(service, "记忆C", "内容C", "history");
-  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
-  const result = await runSleep(
-    ctx, service,
-    baseConfig({ sleepEntityExtractionEnabled: true }),
-    ctx.logger, null, null
-  );
-  const phase = result.phases["entity-extraction"];
-  assert.equal(phase.status, "ok");
-  assert.equal(phase.extracted, 1);
-  assert.ok(store.listEntities().length > 0, "entity minted");
-  assert.ok(service.getAttrsByMemory(mem.id).length > 0, "memory now carries entity attrs");
-  store.close();
-});
-
-test("sleep: a failing extraction does not abort the batch and retries next cycle", async () => {
-  const { service, store } = setup();
-  const bad = makeMemory(service, "坏记忆", "bad 内容", "history");
-  const good = makeMemory(service, "好记忆", "good 内容", "history");
-  const ctx = mockCtx(
-    (user) => (String(user).includes("bad") ? "这不是合法JSON{{{" : ENTITY_LLM_JSON),
-    { provider: "p", model: "m" }
-  );
-  const config = baseConfig({ sleepEntityExtractionEnabled: true });
-  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
-  const phase = first.phases["entity-extraction"];
-  assert.equal(phase.extracted, 1, "good memory extracted");
-  assert.equal(phase.failed, 1, "bad memory counted as failed");
-  assert.equal(phase.status, "ok", "partial success is ok");
-  assert.ok(store.listEntities().length > 0, "at least one entity minted");
-  // Good memory stamped; bad one not → second cycle retries only the bad one.
-  assert.ok(service.getById(good.id).metadata?.entity_extracted_at, "good memory stamped");
-  assert.equal(service.getById(bad.id).metadata?.entity_extracted_at, undefined, "failed memory not stamped");
-  const second = await runSleep(ctx, service, config, ctx.logger, null, null);
-  assert.equal(second.phases["entity-extraction"].extracted, 0, "bad memory still fails");
-  assert.equal(second.phases["entity-extraction"].failed, 1, "failed memory retried");
-  store.close();
-});
-
-test("sleep: metadata merge keeps unrelated fields when stamping (review #4)", async () => {
-  const { service, store } = setup();
-  const mem = makeMemory(service, "记忆M", "内容M", "history");
-  service.setMemoryMetadata(mem.id, { custom_flag: "keep-me" });
-  const ctx = mockCtx(() => ENTITY_LLM_JSON, { provider: "p", model: "m" });
-  await runSleep(ctx, service, baseConfig({ sleepEntityExtractionEnabled: true }), ctx.logger, null, null);
-  const meta = service.getById(mem.id).metadata;
-  assert.equal(meta.custom_flag, "keep-me", "pre-existing metadata not clobbered");
-  assert.ok(meta.entity_extracted_at, "stamp added alongside");
-  store.close();
-});
-
-test("sleep: pending_extracted_at is cleared on success and on failure (review #3)", async () => {
-  const { service, store } = setup();
-  const good = makeMemory(service, "好记忆", "内容G", "history");
-  const bad = makeMemory(service, "坏记忆", "bad 内容", "history");
-  const ctx = mockCtx(
-    (user) => (String(user).includes("bad") ? "不是JSON{{{" : ENTITY_LLM_JSON),
-    { provider: "p", model: "m" }
-  );
-  const config = baseConfig({ sleepEntityExtractionEnabled: true });
-  const first = await runSleep(ctx, service, config, ctx.logger, null, null);
-  const phase = first.phases["entity-extraction"];
-  assert.equal(phase.extracted, 1);
-  assert.equal(phase.failed, 1);
-  assert.equal(service.getById(good.id).metadata?.pending_extracted_at, null, "success clears pending");
-  assert.equal(service.getById(bad.id).metadata?.pending_extracted_at, null, "failure clears pending");
-  store.close();
-});
-
-test("sleep: all-failed extraction surfaces failed status through deriveStatus (review #5)", async () => {
-  const { service, store } = setup();
-  makeMemory(service, "坏记忆1", "bad 一", "history");
-  makeMemory(service, "坏记忆2", "bad 二", "history");
-  const ctx = mockCtx(() => "不是JSON{{{", { provider: "p", model: "m" });
-  const result = await runSleep(ctx, service, baseConfig({ sleepEntityExtractionEnabled: true }), ctx.logger, null, null);
-  const phase = result.phases["entity-extraction"];
-  assert.equal(phase.status, "failed", "all-failed extraction reports failed");
-  assert.equal(phase.failed, 2);
-  assert.ok(["failed", "degraded"].includes(result.status), "deriveStatus folds failed into run status");
-  store.close();
-});
-
-test("store: listForEntityExtraction pages oldest un-stamped candidates (review #2)", async () => {
-  const { service, store } = setup();
-  const a = makeMemory(service, "甲", "内容甲", "history");
-  makeMemory(service, "乙", "内容乙", "history");
-  const archived = makeMemory(service, "归档", "内容归档", "history");
-  store.setArchived(archived.id, true);
-  makeMemory(service, "摘要", "内容摘要", "summary");
-  makeMemory(service, "丙", "内容丙", "history"); // second un-stamped candidate so oldest-first has two to compare
-  service.setMemoryMetadata(a.id, { entity_extracted_at: new Date().toISOString() });
-  const list = store.listForEntityExtraction({ limit: 10, offset: 0 });
-  const titles = list.map((m) => m.title);
-  assert.ok(!titles.includes("归档"), "archived excluded");
-  assert.ok(!titles.includes("摘要"), "summary excluded");
-  assert.ok(!titles.includes("甲"), "already-stamped excluded");
-  assert.ok(titles.includes("乙"), "un-stamped included");
-  assert.ok(titles.includes("丙"), "un-stamped included");
-  assert.equal(list[0].created_at <= list[1].created_at, true, "oldest first");
-  store.close();
-});

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

@@ -358,79 +358,3 @@ test("conflict_pending table persists across store reopen", () => {
   assert.equal(pending[0].reason, "x");
   s2.close();
 });
-
-// --- session lifecycle (v0.6.0): disposed rows are filtered out ------------
-
-test("session_disposed_at column exists and survives migration", () => {
-  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-disposed-"));
-  const path = join(dir, "memory.db");
-  const s1 = createStore(path);
-  const { id } = s1.save({ type: "decision", title: "迁移", content: "c", session_id: "sess-m" });
-  s1.setDisposedBySession("sess-m", true);
-  const row = s1.db.prepare("SELECT session_disposed_at FROM memories WHERE id = ?").get(id);
-  assert.ok(row.session_disposed_at, "dispose timestamp persisted");
-  s1.close();
-  // reopen: column survives
-  const s2 = createStore(path);
-  const live = s2.list({ type: "decision" });
-  assert.ok(!live.some((m) => m.id === id), "disposed row excluded after reopen");
-  s2.close();
-});
-
-test("search and list exclude disposed rows unless includeDisposed", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "decision", title: "活着", content: "keyword alpha", session_id: "s1" });
-  const b = store.save({ type: "decision", title: "被销毁", content: "keyword beta", session_id: "s2" });
-  store.setDisposedBySession("s2", true);
-
-  const searchRes = store.search("keyword");
-  assert.ok(searchRes.some((m) => m.id === a.id), "live row found");
-  assert.ok(!searchRes.some((m) => m.id === b.id), "disposed row excluded from search");
-  const searchIncl = store.search("keyword", { includeDisposed: true });
-  assert.ok(searchIncl.some((m) => m.id === b.id), "includeDisposed surfaces it");
-
-  const listRes = store.list({ type: "decision" });
-  assert.ok(listRes.some((m) => m.id === a.id));
-  assert.ok(!listRes.some((m) => m.id === b.id), "disposed excluded from list");
-  const listIncl = store.list({ type: "decision", includeDisposed: true });
-  assert.ok(listIncl.some((m) => m.id === b.id), "includeDisposed lists it");
-  assert.equal(store.count("decision", { includeDisposed: true }), 2);
-});
-
-test("searchVector excludes disposed rows", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "decision", title: "向量A", content: "v", session_id: "s1" });
-  const b = store.save({ type: "decision", title: "向量B", content: "v", session_id: "s2" });
-  store.setEmbedding(a.id, [1, 0, 0]);
-  store.setEmbedding(b.id, [1, 0, 0]);
-  store.setDisposedBySession("s2", true);
-
-  const res = store.searchVector([1, 0, 0], { limit: 10 });
-  assert.ok(res.some((m) => m.id === a.id));
-  assert.ok(!res.some((m) => m.id === b.id), "disposed row excluded from vector search");
-});
-
-test("setDisposedBySession round-trips and listBySession sees all states", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "decision", title: "会话记忆", content: "c", session_id: "sess-z" });
-  assert.equal(store.setDisposedBySession("sess-z", true), 1, "first dispose flips 1");
-  assert.equal(store.setDisposedBySession("sess-z", true), 0, "re-dispose is a no-op");
-  assert.equal(store.setDisposedBySession("sess-z", false), 1, "restore flips 1");
-  assert.equal(store.setDisposedBySession("sess-z", false), 0, "re-restore is a no-op");
-  assert.equal(store.getById(a.id).session_disposed_at, undefined, "mark cleared after restore");
-
-  const bySession = store.listBySession("sess-z");
-  assert.equal(bySession.length, 1);
-  assert.equal(bySession[0].id, a.id);
-});
-
-test("listBySession hides disposed by default, includeDisposed opts in", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "decision", title: "会话记忆", content: "c", session_id: "sess-y" });
-  store.setDisposedBySession("sess-y", true);
-
-  assert.equal(store.listBySession("sess-y").length, 0, "disposed row hidden by default");
-  const all = store.listBySession("sess-y", { includeDisposed: true });
-  assert.equal(all.length, 1, "includeDisposed reveals it");
-  assert.equal(all[0].id, a.id);
-});

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

@@ -85,21 +85,6 @@ test("turn/end event triggers summarization and stores entries", async () => {
   assert.ok(all.some((m) => m.type === "preference"));
 });
 
-test("session with only snapshotEvents() (DSH 0.1.2-rc.1) still summarizes", async () => {
-  const { events, store } = setup();
-  const handler = events.find((e) => e.name === "session/event").fn;
-  const session = {
-    id: "s6",
-    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
-    snapshotEvents: () => [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;
@@ -109,6 +94,22 @@ test("skips summarization for events other than turn/end", async () => {
   assert.equal(calls.length, 0);
 });
 
+// DSH ≥0.1.2-rc removed Session.events; the session object only exposes
+// snapshotEvents(). Regression for #59: with only the old .events path the
+// collector saw an empty log and no LLM call ever happened.
+test("reads events from snapshotEvents() when Session.events is absent", async () => {
+  const { events, store, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s1",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    snapshotEvents: () => [userMessage("帮我选型"), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "an LLM call must be made");
+  assert.equal(store.count(), 2);
+});
+
 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;

package/test/tools.test.js

@@ -0,0 +1,265 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { assertSupportedJsonSchema, validateJsonSchemaValue } from "@deepseek-ai/dsh-tools";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+
+function setup(embedder) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  const ctx = {
+    tools: {
+      register(def) {
+        registered.push(def);
+        return () => {};
+      }
+    }
+  };
+  const tools = createTools(ctx, service, {}, embedder);
+  return { store, service, tools, registered };
+}
+
+// Collect authoring-DSL regressions in a compiled schema: property-level
+// `required: true` (must be projected to a top-level required array by
+// defineTool) and `minimum`/`maximum` (outside the enforced subset) are
+// rejected by the real harness, so they must never appear post-compilation.
+function walkSchema(node, path, problems) {
+  if (typeof node !== "object" || node === null || Array.isArray(node)) return;
+  if (typeof node.required === "boolean") {
+    problems.push(`${path}.required must be an array (property-level required leaks through)`);
+  }
+  if (Object.hasOwn(node, "minimum") || Object.hasOwn(node, "maximum")) {
+    problems.push(`${path} uses minimum/maximum, which the enforced JSON Schema subset rejects`);
+  }
+  if (node.properties && typeof node.properties === "object") {
+    for (const [key, value] of Object.entries(node.properties)) {
+      walkSchema(value, `${path}.properties.${key}`, problems);
+    }
+  }
+  if (node.items) walkSchema(node.items, `${path}.items`, problems);
+  if (Array.isArray(node.oneOf)) {
+    node.oneOf.forEach((branch, index) => walkSchema(branch, `${path}.oneOf[${index}]`, problems));
+  }
+}
+
+test("registers seven tools with correct names", () => {
+  const { registered } = setup();
+  const names = registered.map((t) => t.name).sort();
+  assert.deepEqual(names, ["memory_archive", "memory_delete", "memory_forget", "memory_list", "memory_save", "memory_search", "memory_update"]);
+});
+
+test("compiled schemas pass the enforced DSH subset (defineTool projection)", () => {
+  const { registered } = setup();
+  assert.equal(registered.length, 7);
+  for (const tool of registered) {
+    assertSupportedJsonSchema(tool.parameters);
+    assertSupportedJsonSchema(tool.output.schema);
+    const problems = [];
+    walkSchema(tool.parameters, `parameters(${tool.name})`, problems);
+    walkSchema(tool.output.schema, `output.schema(${tool.name})`, problems);
+    assert.deepEqual(problems, []);
+  }
+});
+
+test("memory_save executes and stores", async () => {
+  const { registered, store } = setup();
+  const save = registered.find((t) => t.name === "memory_save");
+  const result = await save.execute({ type: "preference", title: "语言", content: "中文", importance: 4 });
+  assert.equal(result.action, "created");
+  assert.equal(store.count(), 1);
+});
+
+test("memory_save merges on matching title within type", async () => {
+  const { registered, store } = setup();
+  const save = registered.find((t) => t.name === "memory_save");
+  const first = await save.execute({ type: "preference", title: "语言", content: "中文" });
+  const second = await save.execute({ type: "preference", title: "语言", content: "简体中文" });
+  assert.equal(first.action, "created");
+  assert.equal(second.action, "merged");
+  assert.equal(first.id, second.id);
+  assert.equal(store.count(), 1);
+});
+
+test("memory_search finds by CJK substring", async () => {
+  const { registered, store, service } = setup();
+  service.saveWithDedupe({ type: "project", title: "记忆插件", content: "SQLite 存储中文记忆", importance: 3 });
+  const search = registered.find((t) => t.name === "memory_search");
+  const result = await search.execute({ query: "中文" });
+  assert.ok(result.items.length >= 1);
+  assert.equal(result.items[0].title, "记忆插件");
+});
+
+test("memory_list filters by type", async () => {
+  const { registered, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "a", content: "x" });
+  service.saveWithDedupe({ type: "project", title: "b", content: "y" });
+  const list = registered.find((t) => t.name === "memory_list");
+  const result = await list.execute({ type: "project" });
+  assert.equal(result.items.length, 1);
+  assert.equal(result.items[0].title, "b");
+});
+
+test("memory_list total reflects the type filter", async () => {
+  const { registered, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "a", content: "x" });
+  service.saveWithDedupe({ type: "preference", title: "b", content: "y" });
+  service.saveWithDedupe({ type: "project", title: "c", content: "z" });
+  const list = registered.find((t) => t.name === "memory_list");
+  const projectRes = await list.execute({ type: "project" });
+  assert.equal(projectRes.total, 1);
+  const allRes = await list.execute({});
+  assert.equal(allRes.total, 3);
+});
+
+test("memory_update modifies an entry", async () => {
+  const { registered, service } = setup();
+  const { memory } = service.saveWithDedupe({ type: "decision", title: "t", content: "c" });
+  const update = registered.find((t) => t.name === "memory_update");
+  const result = await update.execute({ id: memory.id, content: "updated" });
+  assert.equal(result.memory.content, "updated");
+});
+
+test("memory_update on missing id rejects", async () => {
+  const { registered } = setup();
+  const update = registered.find((t) => t.name === "memory_update");
+  await assert.rejects(() => update.execute({ id: "missing", content: "x" }), /memory not found/);
+});
+
+test("memory_delete removes an entry", async () => {
+  const { registered, service, store } = setup();
+  const { memory } = service.saveWithDedupe({ type: "decision", title: "t", content: "c" });
+  const del = registered.find((t) => t.name === "memory_delete");
+  await del.execute({ id: memory.id });
+  assert.equal(store.count(), 0);
+});
+
+test("memory_delete on missing id returns deleted:false", async () => {
+  const { registered } = setup();
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ id: "missing" });
+  assert.equal(result.deleted, false);
+});
+
+test("memory_forget suppresses injection without deleting", async () => {
+  const { registered, service, store } = setup();
+  const { memory } = service.saveWithDedupe({ type: "project", title: "t", content: "c", importance: 5 });
+  const forget = registered.find((t) => t.name === "memory_forget");
+  const result = await forget.execute({ id: memory.id });
+  assert.equal(result.memory.forgotten, true);
+  assert.equal(store.count(undefined, { includeForgotten: true }), 1, "still stored but suppressed");
+});
+
+test("memory_forget on missing id rejects", async () => {
+  const { registered } = setup();
+  const forget = registered.find((t) => t.name === "memory_forget");
+  await assert.rejects(() => forget.execute({ id: "missing" }), /memory not found/);
+});
+
+test("memory_forget restores with forgotten:false", async () => {
+  const { registered, service } = setup();
+  const { memory } = service.saveWithDedupe({ type: "project", title: "t", content: "c", importance: 5 });
+  const forget = registered.find((t) => t.name === "memory_forget");
+  await forget.execute({ id: memory.id });
+  const restored = await forget.execute({ id: memory.id, forgotten: false });
+  assert.equal(restored.memory.forgotten, false);
+});
+
+test("execution results validate against their declared output schemas", async () => {
+  const { registered, service } = setup();
+  const byName = (n) => registered.find((t) => t.name === n);
+
+  const saved = await byName("memory_save").execute({ type: "decision", title: "x", content: "y", tags: ["k"], source: "test" });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_save").output.schema, saved), []);
+
+  service.saveWithDedupe({ type: "project", title: "p", content: "q" });
+  const searchRes = await byName("memory_search").execute({ query: "q" });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_search").output.schema, searchRes), []);
+
+  const listRes = await byName("memory_list").execute({});
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_list").output.schema, listRes), []);
+
+  const updRes = await byName("memory_update").execute({ id: saved.id, content: "z" });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_update").output.schema, updRes), []);
+
+  const forgetRes = await byName("memory_forget").execute({ id: saved.id });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_forget").output.schema, forgetRes), []);
+
+  const delRes = await byName("memory_delete").execute({ id: saved.id });
+  assert.deepEqual(validateJsonSchemaValue(byName("memory_delete").output.schema, delRes), []);
+});
+
+test("memory_search semantic mode merges vector recalls", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+  const embedder = { embed: async () => [1, 0, 0] };
+  createTools(ctx, service, {}, embedder);
+
+  const v = service.saveWithDedupe({ type: "preference", title: "猫", content: "喜欢猫" });
+  store.setEmbedding(v.memory.id, [1, 0, 0]);
+  service.saveWithDedupe({ type: "preference", title: "狗", content: "喜欢狗" });
+
+  const search = registered.find((t) => t.name === "memory_search");
+  // literal query matches only 猫; vector recall also surfaces it via embedding
+  const res = await search.execute({ query: "猫", semantic: true });
+  assert.ok(res.items.some((m) => m.title === "猫"), "vector + keyword merged result contains the hit");
+  // mode=vector keeps keyword items too (dedup merge)
+  const res2 = await search.execute({ query: "猫", mode: "vector" });
+  assert.ok(res2.items.some((m) => m.title === "猫"));
+});
+
+test("memory_search falls back to keyword when embedder unavailable or returns null", async () => {
+  // No embedder passed → plain keyword search still works.
+  const { registered, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文交流" });
+  const search = registered.find((t) => t.name === "memory_search");
+  const res = await search.execute({ query: "中文", semantic: true });
+  assert.equal(res.items.length, 1);
+  assert.equal(res.items[0].title, "语言");
+
+  // Embedder that resolves null (provider disabled) → keyword fallback.
+  const store = createStore(":memory:");
+  const service2 = createService({ store, mirror: null, config: {} });
+  const registered2 = [];
+  const ctx = { tools: { register(def) { registered2.push(def); return () => {}; } } };
+  createTools(ctx, service2, {}, { embed: async () => null });
+  service2.saveWithDedupe({ type: "preference", title: "语言", content: "中文交流" });
+  const search2 = registered2.find((t) => t.name === "memory_search");
+  const res2 = await search2.execute({ query: "中文", semantic: true });
+  assert.equal(res2.items.length, 1);
+});
+
+// --- memory_archive (item ⑤: archive + verifiable recovery) ----------------
+
+test("memory_archive hides an entry and memory_unarchive restores it", async () => {
+  const { registered, service } = setup();
+  const { memory: m } = service.saveWithDedupe({ type: "project", title: "t", content: "c" });
+  const archive = registered.find((t) => t.name === "memory_archive");
+  const archived = await archive.execute({ id: m.id });
+  assert.equal(archived.memory.archived, true);
+  assert.ok(!service.list({ type: "project" }).some((x) => x.id === m.id), "archived hidden from default list");
+  const restored = await archive.execute({ id: m.id, archived: false });
+  assert.equal(restored.memory.archived, false);
+  assert.ok(service.list({ type: "project" }).some((x) => x.id === m.id), "restored entry visible again");
+});
+
+test("memory_list include_archived lists hidden entries so they can be restored", async () => {
+  const { registered, service } = setup();
+  const { memory: m } = service.saveWithDedupe({ type: "preference", title: "a", content: "x" });
+  service.setArchived(m.id, true);
+  const list = registered.find((t) => t.name === "memory_list");
+  const hidden = await list.execute({ type: "preference", include_archived: true });
+  assert.ok(hidden.items.some((x) => x.id === m.id), "archived entry discoverable");
+  assert.equal(hidden.total, 1, "total counts the archived entry");
+  const visible = await list.execute({ type: "preference" });
+  assert.ok(!visible.items.some((x) => x.id === m.id), "archived entry hidden by default");
+});
+
+test("memory_archive on missing id rejects", async () => {
+  const { registered } = setup();
+  const archive = registered.find((t) => t.name === "memory_archive");
+  await assert.rejects(() => archive.execute({ id: "missing" }), /memory not found/);
+});

package/.github/workflows/publish.yml

@@ -1,58 +0,0 @@
-name: Publish to npm
-
-# 发布路径：registry.npmjs.org 在本机云服务器被出口 SNI 过滤 + 17897 隧道不稳定，
-# 改由 GitHub runner 发布（不依赖本机出网）。打 v* tag 自动触发，或 workflow_dispatch 手动。
-#
-# ⚠️ 版本号机制（血的教训）：
-#   root package.json 在 git 里永远停在 0.7.2，真实版本号在 dsh-mneme/package.json。
-#   npm 在跑 prepublishOnly 之前就已加载 manifest，脚本里改 root 版本不生效，
-#   会把 root 的旧版本（0.7.2）发出去。必须在 npm publish 之前显式同步 root 版本。
-
-on:
-  push:
-    tags:
-      - 'v*'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 24
-          registry-url: https://registry.npmjs.org/
-
-      - name: Registry current state (diagnostic)
-        run: |
-          npm view @modusensus/dsh-mneme versions --json || true
-          npm view @modusensus/dsh-mneme time --json || true
-
-      # 关键：先同步 root 版本 → 再 publish（prepublishOnly 改版本不可靠）
-      - name: Sync root version from dsh-mneme
-        run: |
-          V="$(node -p "require('./dsh-mneme/package.json').version")"
-          echo "Syncing root package.json to v${V}"
-          node -e "const fs=require('fs');const v=process.argv[1];const p=JSON.parse(fs.readFileSync('./package.json','utf8'));p.version=v;fs.writeFileSync('./package.json',JSON.stringify(p,null,2)+'\n')" "$V"
-          node -p "console.log('root now:', require('./package.json').version)"
-
-      - name: Publish @modusensus/dsh-mneme (skip if exists)
-        run: |
-          V="$(node -p "require('./dsh-mneme/package.json').version")"
-          if npm view "@modusensus/dsh-mneme@${V}" version >/dev/null 2>&1; then
-            echo "v${V} already published on registry — skipping"
-          else
-            npm publish
-          fi
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Verify published version
-        run: |
-          V="$(node -p "require('./dsh-mneme/package.json').version")"
-          echo "Published: $(npm view "@modusensus/dsh-mneme@${V}" version)"