@modusensus/dsh-mneme 0.5.3 → 0.6.1

package/test/service.test.js

@@ -76,6 +76,10 @@ test("toApiList maps store rows to wire DTOs", () => {
   assert.equal(dto[0].title, "选型");
   assert.equal(dto[0].content, "node:sqlite");
   assert.equal(dto[0].importance, 3);
+  // session_id rides the DTO when present (session lifecycle needs it)
+  const withSession = service.saveWithDedupe({ type: "decision", title: "带会话", content: "y", session_id: "sess-x" });
+  const dto2 = service.toApiList([withSession.memory]);
+  assert.equal(dto2[0].session_id, "sess-x");
 });
 
 test("mergeHumanEdits skips edits without id and keeps applying the rest", () => {
@@ -327,3 +331,105 @@ test("Bug7: injection ranking re-weights by quality_score (degraded memories ran
   assert.equal(candidates[0].title, "高质量", "100-quality preference leads the degraded one");
   assert.equal(candidates[1].title, "元记忆");
 });
+
+// --- session lifecycle (v0.6.0): dispose/restore by session -----------------
+// session_disposed_at is orthogonal to `archived`: dispose hides only entries
+// born in the deleted session, and restore never resurrects user-archived ones.
+
+test("disposeBySession marks only that session's memories", () => {
+  const store = createStore(":memory:");
+  const svc = createService({ store, mirror: null, config: {} });
+  const s1 = svc.saveWithDedupe({ type: "project", title: "会话A记忆", content: "x", session_id: "sess-1" });
+  svc.saveWithDedupe({ type: "project", title: "会话B记忆", content: "y", session_id: "sess-2" });
+
+  const res = svc.disposeBySession("sess-1");
+  assert.deepEqual(res, { disposed: 1 });
+  assert.ok(svc.getById(s1.memory.id).session_disposed_at, "session-1 memory marked disposed");
+  // disposed memories vanish from default list (like archived)
+  assert.ok(!svc.list({ type: "project" }).some((m) => m.id === s1.memory.id), "disposed hidden from default list");
+  const other = svc.list({ type: "project", includeDisposed: true });
+  assert.ok(other.some((m) => m.title === "会话B记忆" && !m.session_disposed_at), "other session untouched");
+});
+
+test("restoreBySession clears the dispose mark and makes entries visible again", () => {
+  const store = createStore(":memory:");
+  const svc = createService({ store, mirror: null, config: {} });
+  const s1 = svc.saveWithDedupe({ type: "project", title: "存档会话", content: "x", session_id: "sess-9" });
+  svc.disposeBySession("sess-9");
+
+  assert.ok(!svc.list({ type: "project" }).some((m) => m.id === s1.memory.id), "hidden while disposed");
+  const res = svc.restoreBySession("sess-9");
+  assert.deepEqual(res, { restored: 1 });
+  assert.equal(svc.getById(s1.memory.id).session_disposed_at, undefined, "dispose mark cleared");
+  assert.ok(svc.list({ type: "project" }).some((m) => m.id === s1.memory.id), "visible again");
+});
+
+test("disposeBySession is idempotent: re-disposing returns 0", () => {
+  const store = createStore(":memory:");
+  const svc = createService({ store, mirror: null, config: {} });
+  svc.saveWithDedupe({ type: "project", title: "重复销毁", content: "x", session_id: "sess-3" });
+
+  assert.deepEqual(svc.disposeBySession("sess-3"), { disposed: 1 });
+  assert.deepEqual(svc.disposeBySession("sess-3"), { disposed: 0 }, "no rows flipped the second time");
+});
+
+test("disposeBySession on an unknown session is a no-op", () => {
+  const store = createStore(":memory:");
+  const svc = createService({ store, mirror: null, config: {} });
+  assert.deepEqual(svc.disposeBySession("nope"), { disposed: 0 });
+  assert.deepEqual(svc.restoreBySession("nope"), { restored: 0 });
+});
+
+test("legacy rows without session_id are never touched by session lifecycle", () => {
+  const store = createStore(":memory:");
+  const svc = createService({ store, mirror: null, config: {} });
+  const legacy = svc.saveWithDedupe({ type: "preference", title: "全局记忆", content: "no session", session_id: undefined });
+
+  svc.disposeBySession("sess-x");
+  assert.equal(svc.getById(legacy.memory.id).session_disposed_at, undefined, "global memory survives session dispose");
+});
+
+test("restoreBySession does NOT resurrect user-archived memories (orthogonal)", () => {
+  const store = createStore(":memory:");
+  const svc = createService({ store, mirror: null, config: {} });
+  // user manually archived this one (archived=true), then the session is disposed
+  const { memory: userArchived } = svc.saveWithDedupe({ type: "decision", title: "手动归档", content: "x", session_id: "sess-4" });
+  svc.setArchived(userArchived.id, true);
+  svc.disposeBySession("sess-4");
+
+  svc.restoreBySession("sess-4");
+  assert.equal(svc.getById(userArchived.id).archived, true, "user archive survives restore");
+  assert.equal(svc.getById(userArchived.id).session_disposed_at, undefined, "dispose mark cleared but archive kept");
+  assert.ok(!svc.list({ type: "decision" }).some((m) => m.id === userArchived.id), "still hidden by user archive");
+});
+
+test("listBySession returns only that session's memories via wire DTOs", () => {
+  const store = createStore(":memory:");
+  const svc = createService({ store, mirror: null, config: {} });
+  const { memory } = svc.saveWithDedupe({ type: "decision", title: "会话决策", content: "d", session_id: "sess-7" });
+  svc.saveWithDedupe({ type: "decision", title: "别会话", content: "e", session_id: "sess-8" });
+
+  const rows = svc.listBySession("sess-7");
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].id, memory.id);
+  assert.equal(rows[0].title, "会话决策");
+  assert.equal(rows[0].session_id, "sess-7");
+});
+
+test("listBySession DTO hides disposed by default and flags it when included", () => {
+  const store = createStore(":memory:");
+  const svc = createService({ store, mirror: null, config: {} });
+  const { memory } = svc.saveWithDedupe({ type: "decision", title: "会话决策", content: "d", session_id: "sess-9" });
+  svc.disposeBySession("sess-9");
+
+  assert.equal(svc.listBySession("sess-9").length, 0, "disposed hidden by default");
+  const visible = svc.listBySession("sess-9", { includeDisposed: true });
+  assert.equal(visible.length, 1);
+  assert.equal(visible[0].id, memory.id);
+  assert.equal(visible[0].disposed, true, "DTO carries disposed marker so restore is not blind");
+
+  svc.restoreBySession("sess-9");
+  const restored = svc.listBySession("sess-9");
+  assert.equal(restored.length, 1, "restore brings it back to default view");
+  assert.equal(restored[0].disposed, undefined, "marker cleared after restore");
+});

package/test/store.test.js

@@ -358,3 +358,79 @@ 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/test/tools.test.js

@@ -142,6 +142,26 @@ test("memory_delete on missing id returns deleted:false", async () => {
   assert.equal(result.deleted, false);
 });
 
+test("memory_delete by query deletes the best match (no id round-trip)", async () => {
+  const { registered, service, store } = setup();
+  const { memory } = service.saveWithDedupe({ type: "preference", title: "喜欢 Rust", content: "用户偏好 Rust 优先于 Go", importance: 4 });
+  service.saveWithDedupe({ type: "preference", title: "喜欢 Python", content: "用户偏好 Python 写脚本", importance: 3 });
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ query: "Rust" });
+  assert.equal(result.deleted, true);
+  assert.equal(service.getById(memory.id), undefined, "best-matching Rust entry removed");
+  assert.equal(store.count(), 1, "non-matching entry untouched");
+});
+
+test("memory_delete by query with no match returns deleted:false", async () => {
+  const { registered, service, store } = setup();
+  service.saveWithDedupe({ type: "preference", title: "喜欢 Rust", content: "用户偏好 Rust", importance: 4 });
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ query: "完全不存在的关键词xyz" });
+  assert.equal(result.deleted, false);
+  assert.equal(store.count(), 1, "nothing removed when no match");
+});
+
 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 });

package/test/wiki-link.test.js

@@ -0,0 +1,332 @@
+// v0.6.1 Wiki-Link（显式跨记忆链接）测试。
+// 覆盖：解析器 parseWikiLinks（正常/显示文本/未闭合/空/多链接/非法）/
+// resolveWikiLink 大小写匹配 / 存储幂等（同对只写一条、目标不存在跳过）/
+// links_to 的 partial 唯一索引（仅 links_to 去重，其余 relation 保持 append-only）/
+// saveWikiLinks 幂等 / service 三 API（getBacklinks/getForwardLinks/
+// resolveWikiLink）与 saveWithDedupe 的 wikiLinkEnabled hook / 三个只读 HTTP 端点。
+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";
+import { parseWikiLinks } from "../src/parser/wiki-link.js";
+
+function openStore() {
+  return createStore(":memory:");
+}
+
+function makeService(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+/** Let fire-and-forget enqueue tasks (wiki-link resolve) settle. */
+const flush = () => new Promise((resolve) => setTimeout(resolve, 5));
+
+function seed(service, title, content, type = "preference") {
+  return service.saveWithDedupe({ type, title, content, importance: 3 }).memory;
+}
+
+// ============================================================ parser
+
+test("parseWikiLinks: plain [[target]] returns display=target", () => {
+  assert.deepEqual(parseWikiLinks("看看 [[Alpha]] 这篇"), [
+    { display: "Alpha", target: "Alpha" }
+  ]);
+});
+
+test("parseWikiLinks: [[显示|target]] keeps display text separate from target", () => {
+  assert.deepEqual(parseWikiLinks("参考 [[精彩解读|Alpha]] 一文"), [
+    { display: "精彩解读", target: "Alpha" }
+  ]);
+});
+
+test("parseWikiLinks: unclosed [[ marker is ignored", () => {
+  assert.deepEqual(parseWikiLinks("这里有个没闭合的 [[Alpha"), []);
+  assert.deepEqual(parseWikiLinks("[[Alpha] 只有一个括号"), []);
+});
+
+test("parseWikiLinks: empty targets are ignored", () => {
+  assert.deepEqual(parseWikiLinks("[[]]"), []);
+  assert.deepEqual(parseWikiLinks("[[   ]]"), []);
+  assert.deepEqual(parseWikiLinks("[[显示|]]"), []);
+  assert.deepEqual(parseWikiLinks("[[|]]"), []);
+});
+
+test("parseWikiLinks: multiple links are all returned in order", () => {
+  const links = parseWikiLinks("[[A]] 与 [[B]] 以及 [[C|D]]");
+  assert.deepEqual(links, [
+    { display: "A", target: "A" },
+    { display: "B", target: "B" },
+    { display: "C", target: "D" }
+  ]);
+});
+
+test("parseWikiLinks: multi-pipe and bracket-nested markers are illegal", () => {
+  assert.deepEqual(parseWikiLinks("[[a|b|c]]"), [], "multi-pipe skipped");
+  assert.deepEqual(parseWikiLinks("[[a [[b]] c]]"), [
+    { display: "b", target: "b" }
+  ], "only the well-formed inner [[b]] is kept");
+});
+
+test("parseWikiLinks: non-string / empty content returns []", () => {
+  assert.deepEqual(parseWikiLinks(""), []);
+  assert.deepEqual(parseWikiLinks(undefined), []);
+  assert.deepEqual(parseWikiLinks(null), []);
+  assert.deepEqual(parseWikiLinks("没有链接的普通文本"), []);
+});
+
+test("parseWikiLinks: display falls back to target when the display side is empty", () => {
+  assert.deepEqual(parseWikiLinks("[[|Beta]]"), [
+    { display: "Beta", target: "Beta" }
+  ]);
+});
+
+// ============================================================ storage
+
+test("partial unique index on links_to (from_entity,to_entity) is created", () => {
+  const store = openStore();
+  const idx = store.db.prepare(
+    "SELECT name, sql FROM sqlite_master WHERE type='index' AND name='idx_relations_wikilink'"
+  ).get();
+  assert.ok(idx, "idx_relations_wikilink exists");
+  assert.match(idx.sql, /WHERE relation_type = 'links_to'/i,
+    "index is partial — scoped to links_to only");
+  const fullUnique = store.db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='index' AND name='idx_relations_unique'"
+  ).get();
+  assert.ok(!fullUnique, "no full-table unique index (keeps other types append-only)");
+  store.close();
+});
+
+test("saveWikiLinks: same target pair writes exactly one row (idempotent)", () => {
+  const store = openStore();
+  const a = store.save({ type: "preference", title: "Alpha", content: "c", tags: [] });
+  store.save({ type: "project", title: "Beta", content: "c", tags: [] });
+  const r1 = store.saveWikiLinks({ memoryId: a.id, title: a.title, targets: ["Beta"] });
+  const r2 = store.saveWikiLinks({ memoryId: a.id, title: a.title, targets: ["Beta"] });
+  assert.equal(r1.saved.length, 1);
+  assert.equal(r2.saved.length, 0, "second call is a no-op");
+  assert.deepEqual(r2.skipped, []);
+  const rels = store.getRelations(a.title).filter((r) => r.relation_type === "links_to");
+  assert.equal(rels.length, 1, "one links_to row total");
+  assert.equal(rels[0].from_entity, "Alpha");
+  assert.equal(rels[0].to_entity, "Beta");
+  assert.equal(rels[0].memory_id, a.id);
+  store.close();
+});
+
+test("saveWikiLinks: missing target is skipped, not an error (fail-safe)", () => {
+  const store = openStore();
+  const a = store.save({ type: "preference", title: "Alpha", content: "c", tags: [] });
+  store.save({ type: "project", title: "Beta", content: "c", tags: [] });
+  const r = store.saveWikiLinks({
+    memoryId: a.id,
+    title: a.title,
+    targets: ["不存在", "Beta"]
+  });
+  assert.equal(r.saved.length, 1);
+  assert.deepEqual(r.skipped, ["不存在"]);
+  store.close();
+});
+
+test("saveWikiLinks: target title matches case-insensitively", () => {
+  const store = openStore();
+  const a = store.save({ type: "preference", title: "Alpha", content: "c", tags: [] });
+  const b = store.save({ type: "project", title: "Beta", content: "c", tags: [] });
+  const r = store.saveWikiLinks({ memoryId: a.id, title: a.title, targets: ["BETA"] });
+  assert.equal(r.saved.length, 1, "lowercase target resolves the mixed-case title");
+  assert.equal(r.skipped.length, 0);
+  const rel = store.getRelations(a.title).find((x) => x.relation_type === "links_to");
+  assert.ok(rel, "relation written");
+  // resolved target memory carried in metadata
+  assert.equal(rel.metadata?.target_memory_id, b.id);
+  store.close();
+});
+
+test("saveRelation stays append-only for non-links_to (preserves extractor/dream semantics)", () => {
+  const store = openStore();
+  store.saveRelation({ from_entity: "X", to_entity: "Y", relation_type: "uses" });
+  store.saveRelation({ from_entity: "X", to_entity: "Y", relation_type: "uses" });
+  // two rows — not deduped. (saveRelation's return is a SELECT LIMIT 1, so it
+  // always yields the first matching row; the row count is the real signal.)
+  assert.equal(store.getRelations("X").filter((r) => r.relation_type === "uses").length, 2);
+  store.close();
+});
+
+test("partial unique index dedups links_to at the DB level", () => {
+  const store = openStore();
+  store.saveRelation({ from_entity: "A", to_entity: "B", relation_type: "links_to" });
+  assert.throws(
+    () => store.saveRelation({ from_entity: "A", to_entity: "B", relation_type: "links_to" }),
+    /UNIQUE constraint failed/,
+    "second links_to for the same pair is rejected by idx_relations_wikilink"
+  );
+  store.close();
+});
+
+// ============================================================ service read APIs
+
+test("service.getForwardLinks returns target memories the memory links to", () => {
+  const { store, service } = makeService({ wikiLinkEnabled: true });
+  const a = seed(service, "Alpha", "参见 [[Beta]]", "preference");
+  const b = seed(service, "Beta", "正文", "project");
+  const rel = store.saveWikiLinks({ memoryId: a.id, title: a.title, targets: ["Beta"] });
+  assert.equal(rel.saved.length, 1);
+  const links = service.getForwardLinks(a.id);
+  assert.equal(links.length, 1);
+  assert.equal(links[0].target.id, b.id);
+  assert.equal(links[0].target.title, "Beta");
+  assert.equal(links[0].relation.relation_type, "links_to");
+  store.close();
+});
+
+test("service.getBacklinks returns source memories that link to a memory", () => {
+  const { store, service } = makeService({ wikiLinkEnabled: true });
+  const a = seed(service, "Alpha", "参见 [[Beta]]", "preference");
+  const b = seed(service, "Beta", "正文", "project");
+  store.saveWikiLinks({ memoryId: a.id, title: a.title, targets: ["beta"] }); // case-insensitive resolve
+  const backlinks = service.getBacklinks(b.id);
+  assert.equal(backlinks.length, 1);
+  assert.equal(backlinks[0].source.id, a.id);
+  assert.equal(backlinks[0].source.title, "Alpha");
+  store.close();
+});
+
+test("service.resolveWikiLink matches titles case-insensitively", () => {
+  const { store, service } = makeService();
+  store.save({ type: "project", title: "Beta", content: "c", tags: [] });
+  const mem = service.resolveWikiLink("BETA");
+  assert.ok(mem, "resolved");
+  assert.equal(mem.title, "Beta");
+  assert.equal(service.resolveWikiLink("不存在"), undefined);
+  store.close();
+});
+
+// ============================================================ service hook
+
+test("saveWithDedupe resolves [[wiki-links]] when wikiLinkEnabled=true", async () => {
+  const { store, service } = makeService({ wikiLinkEnabled: true });
+  seed(service, "Beta", "正文", "project");
+  seed(service, "Alpha", "参见 [[Beta]] 和 [[不存在]]", "preference");
+  await flush(); // fire-and-forget enqueue task settles
+  const rels = store.getRelations("Alpha").filter((r) => r.relation_type === "links_to");
+  assert.equal(rels.length, 1, "Beta resolved; 不存在 skipped");
+  assert.equal(rels[0].to_entity, "Beta");
+  store.close();
+});
+
+test("saveWithDedupe writes no links_to when wikiLinkEnabled=false (default)", async () => {
+  const { store, service } = makeService();
+  seed(service, "Beta", "正文", "project");
+  seed(service, "Alpha", "参见 [[Beta]]", "preference");
+  await flush();
+  assert.equal(store.getRelations("Alpha").filter((r) => r.relation_type === "links_to").length, 0);
+  store.close();
+});
+
+test("service.update re-resolves [[wiki-links]] for edited content", async () => {
+  const { store, service } = makeService({ wikiLinkEnabled: true });
+  seed(service, "Beta", "正文", "project");
+  const a = seed(service, "Alpha", "暂无链接", "preference");
+  service.update(a.id, { content: "现在指向 [[Beta]]" });
+  await flush();
+  const rels = store.getRelations("Alpha").filter((r) => r.relation_type === "links_to");
+  assert.equal(rels.length, 1);
+  assert.equal(rels[0].to_entity, "Beta");
+  store.close();
+});
+
+// ============================================================ HTTP endpoints
+
+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) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = "GET";
+  r.headers = {};
+  return r;
+}
+
+function setup(apiToken = "") {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, commands, null, undefined, apiToken);
+  return { store, service, routes };
+}
+
+function wikiRoute(routes, path) {
+  return routes.find((r) => r.path === path);
+}
+
+test("three wiki-link endpoints are registered and open without apiToken", async () => {
+  const { routes } = setup("secret-token");
+  for (const p of [
+    "/api/dsh-mneme/wikilinks/backlinks",
+    "/api/dsh-mneme/wikilinks/forward",
+    "/api/dsh-mneme/wikilinks/resolve"
+  ]) {
+    assert.ok(wikiRoute(routes, p), `${p} registered`);
+  }
+  // read-only: missing param is a 400, never a 401
+  const back = wikiRoute(routes, "/api/dsh-mneme/wikilinks/backlinks");
+  const res = new FakeRes();
+  await back.handler(req("/api/dsh-mneme/wikilinks/backlinks"), res);
+  assert.equal(res.statusCode, 400);
+});
+
+test("GET backlinks returns linking source memories", async () => {
+  const { routes, store, service } = setup();
+  const a = seed(service, "Alpha", "参见 [[Beta]]", "preference");
+  const b = seed(service, "Beta", "正文", "project");
+  store.saveWikiLinks({ memoryId: a.id, title: a.title, targets: ["Beta"] });
+  const route = wikiRoute(routes, "/api/dsh-mneme/wikilinks/backlinks");
+  const res = new FakeRes();
+  await route.handler(req(`/api/dsh-mneme/wikilinks/backlinks?id=${b.id}`), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.memoryId, b.id);
+  assert.equal(data.backlinks.length, 1);
+  assert.equal(data.backlinks[0].title, "Alpha");
+  assert.equal(data.backlinks[0].id, a.id);
+});
+
+test("GET forward links returns target memories", async () => {
+  const { routes, store, service } = setup();
+  const a = seed(service, "Alpha", "参见 [[Beta]]", "preference");
+  const b = seed(service, "Beta", "正文", "project");
+  store.saveWikiLinks({ memoryId: a.id, title: a.title, targets: ["Beta"] });
+  const route = wikiRoute(routes, "/api/dsh-mneme/wikilinks/forward");
+  const res = new FakeRes();
+  await route.handler(req(`/api/dsh-mneme/wikilinks/forward?id=${a.id}`), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.links.length, 1);
+  assert.equal(data.links[0].title, "Beta");
+  assert.equal(data.links[0].id, b.id);
+});
+
+test("GET resolve matches title case-insensitively and 404s when absent", async () => {
+  const { routes, store, service } = setup();
+  store.save({ type: "project", title: "Beta", content: "c", tags: [] });
+  const route = wikiRoute(routes, "/api/dsh-mneme/wikilinks/resolve");
+  const ok = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/wikilinks/resolve?title=BETA"), ok);
+  assert.equal(ok.statusCode, 200);
+  assert.equal(JSON.parse(ok.body).memory.title, "Beta");
+  const missing = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/wikilinks/resolve?title=nope"), missing);
+  assert.equal(missing.statusCode, 404);
+});