@modusensus/dsh-mneme 0.6.1 → 0.6.5

package/src/store.js

@@ -1,5 +1,6 @@
 import { DatabaseSync } from "node:sqlite";
 import { randomUUID } from "node:crypto";
+import { sanitizeTags } from "./parser/tag.js";
 
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS memories (
@@ -1684,6 +1685,162 @@ export function createStore(path) {
     return memories;
   }
 
+  // --- tag storage (v0.6.2) ------------------------------------------------
+  // Tags ride the snapshot-style entity_attrs table (attr_key='tags'), so one
+  // memory has exactly one live tags row; setMemoryTags invalidates any prior
+  // live row and inserts a fresh one (idempotent overwrite). entity_id is the
+  // memory id itself (the memory is its own tag entity), memory_id is kept so
+  // the existing memory-scoped attr queries (getAttrsByMemory / findMemoriesByAttr)
+  // and the bulk tag map all work without a special path.
+
+  /** Normalize an arbitrary tags input to a deduplicated string array.
+   *  Delegates to parser/tag.js sanitizeTags (shared validation with parseTags
+   *  and the autoDream tag-extractor): strips a leading `#`, trims, drops
+   *  non-strings/blanks/over-long/illegal-char tags. Kept as a thin alias so
+   *  the tag write path validates identically to the parser path. */
+  function normalizeTags(tags) {
+    return sanitizeTags(tags);
+  }
+
+  /**
+   * Set (overwrite) the live tag set for a memory. Exactly one tags row stays
+   * live per memory: any prior live row is invalidated first, then one fresh
+   * row is written (no-op when tags is empty — the invalidated row is removed
+   * so "clear tags" = no live row). Returns the stored tag array.
+   */
+  function setMemoryTags(memoryId, tags) {
+    const arr = normalizeTags(tags);
+    const now = nowIso();
+    // Atomic: the invalidation and the fresh row must land together, so a
+    // mid-write crash never leaves the old live row gone without a replacement.
+    // SAVEPOINT (not BEGIN) so this nests safely inside service.transaction().
+    db.exec("SAVEPOINT set_memory_tags");
+    try {
+      db.prepare(
+        `UPDATE entity_attrs SET valid_until = ?
+         WHERE attr_key = 'tags' AND memory_id = ? AND valid_until IS NULL`
+      ).run(now, memoryId);
+      if (arr.length) {
+        const id = randomUUID();
+        db.prepare(
+          `INSERT INTO entity_attrs (id, entity_id, attr_key, attr_value, memory_id, valid_from, valid_until, confidence, source)
+           VALUES (?, ?, 'tags', ?, ?, ?, NULL, 1.0, 'manual')`
+        ).run(id, memoryId, JSON.stringify(arr), memoryId, now);
+      }
+      db.exec("RELEASE set_memory_tags");
+    } catch (e) {
+      db.exec("ROLLBACK TO set_memory_tags");
+      db.exec("RELEASE set_memory_tags");
+      throw e;
+    }
+    return arr;
+  }
+
+  /** Live tags for a memory ([] when none / unknown). */
+  function getMemoryTags(memoryId) {
+    const row = db.prepare(
+      `SELECT attr_value FROM entity_attrs
+       WHERE attr_key = 'tags' AND memory_id = ? AND valid_until IS NULL
+       ORDER BY valid_from DESC LIMIT 1`
+    ).get(memoryId);
+    if (!row) return [];
+    try {
+      const arr = JSON.parse(row.attr_value);
+      return Array.isArray(arr) ? arr : [];
+    } catch {
+      return [];
+    }
+  }
+
+  /** Bulk live-tags lookup for mirror rendering. Returns Map<memoryId, string[]>. */
+  function getMemoryTagsMap(ids) {
+    const out = new Map();
+    const list = (Array.isArray(ids) ? ids : []).filter(Boolean);
+    for (let i = 0; i < list.length; i += 100) {
+      const chunk = list.slice(i, i + 100);
+      const rows = db.prepare(
+        `SELECT memory_id, attr_value FROM entity_attrs
+         WHERE attr_key = 'tags' AND valid_until IS NULL
+           AND memory_id IN (${chunk.map(() => "?").join(",")})`
+      ).all(...chunk);
+      for (const row of rows) {
+        try {
+          const arr = JSON.parse(row.attr_value);
+          if (Array.isArray(arr) && arr.length) out.set(row.memory_id, arr);
+        } catch { /* corrupt row: skip */ }
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Memories carrying a live tags row that contains EVERY requested tag
+   * (AND semantics for a multi-tag query). attr_value is a JSON array, so the
+   * match uses quoted `"tag"` substrings — `tag:lin` never collides with
+   * `linux` because JSON array elements are quote-delimited. Only live rows
+   * (valid_until IS NULL) with a memory reference participate; each memory
+   * appears once.
+   */
+  function findMemoriesByTags(tags) {
+    const list = normalizeTags(tags);
+    if (!list.length) return [];
+    const where = list.map(() => `attr_value LIKE ? ESCAPE '\\'`).join(" AND ");
+    const params = list.map((t) => `%"${escapeLike(t)}"%`);
+    const rows = db.prepare(
+      `SELECT DISTINCT memory_id FROM entity_attrs
+       WHERE attr_key = 'tags' AND valid_until IS NULL
+         AND memory_id IS NOT NULL AND memory_id != ''
+         AND (${where})`
+    ).all(...params);
+    // Same live-memory filter as getDirectory/store.search: forgotten/archived/
+    // session-disposed memories are invisible to `tag:` recall.
+    const stmt = db.prepare(
+      "SELECT * FROM memories WHERE id = ? AND forgotten = 0 AND archived = 0 AND session_disposed_at IS NULL"
+    );
+    const memories = [];
+    for (const { memory_id } of rows) {
+      const row = stmt.get(memory_id);
+      if (row) memories.push(toRow(row));
+    }
+    return memories;
+  }
+
+  /**
+   * Directory view (v0.6.3): group live memories by their entity_attrs-backed
+   * tag set. A memory carrying N tags appears under all N tag folders; a memory
+   * with no live tags lands in `untagged`. Only live rows participate —
+   * forgotten, archived and session-disposed memories are excluded. Groups are
+   * ordered by tag (locale-aware), group members and untagged follow the
+   * canonical memory order (importance DESC, updated_at DESC, id).
+   * @returns {{groups: {tag: string, memories: object[]}[], untagged: object[]}}
+   */
+  function getDirectory() {
+    const rows = db.prepare(
+      `SELECT * FROM memories
+       WHERE forgotten = 0 AND archived = 0 AND session_disposed_at IS NULL
+       ORDER BY importance DESC, updated_at DESC, id`
+    ).all();
+    const memories = rows.map(toRow);
+    const tagMap = getMemoryTagsMap(memories.map((m) => m.id));
+    const byTag = new Map(); // tag -> memory[]
+    const untagged = [];
+    for (const m of memories) {
+      const tags = tagMap.get(m.id);
+      if (!tags || tags.length === 0) {
+        untagged.push(m);
+        continue;
+      }
+      for (const tag of tags) {
+        if (!byTag.has(tag)) byTag.set(tag, []);
+        byTag.get(tag).push(m);
+      }
+    }
+    const groups = [...byTag.entries()]
+      .sort((a, b) => a[0].localeCompare(b[0]))
+      .map(([tag, ms]) => ({ tag, memories: ms }));
+    return { groups, untagged };
+  }
+
   /**
    * Record a typed relation between two entities. metadata (optional) is a
    * free-form JSON blob describing the relation. Relations are append-only —
@@ -2055,6 +2212,11 @@ export function createStore(path) {
     getAttrHistory,
     getAttrsByMemory,
     findMemoriesByAttr,
+    setMemoryTags,
+    getMemoryTags,
+    getMemoryTagsMap,
+    findMemoriesByTags,
+    getDirectory,
     saveRelation,
     saveWikiLinks,
     findByTitle,

package/test/api.test.js

@@ -467,3 +467,83 @@ test("Bug10: vector-reindex with an embed-only OpenAI-compatible embedder return
   assert.equal(vectorIndex.dimension(), 3, "dimension written to vector_meta");
   assert.equal(vectorIndex.getEmbedding(service.all()[0].id).length, 3, "embedding persisted");
 });
+
+// --- memory tags (v0.6.2) ---------------------------------------------------
+
+test("GET /api/dsh-mneme/memory/tags returns live tags and the manual gate", async () => {
+  const { routes, service } = setup();
+  const mem = service.saveWithDedupe({ type: "preference", title: "A", content: "x" }).memory;
+  service.setMemoryTags(mem.id, ["bash", "考研"]);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/tags");
+  const res = new FakeRes();
+  await route.handler(req(`/api/dsh-mneme/memory/tags?id=${mem.id}`), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.deepEqual(data.tags, ["bash", "考研"], "authoritative entity_attrs tags");
+  assert.equal(data.manualTagEnabled, true, "gate defaults on");
+});
+
+test("POST /api/dsh-mneme/memory/tags overwrites the tag set", async () => {
+  const { routes, service } = setup();
+  const mem = service.saveWithDedupe({ type: "preference", title: "A", content: "x" }).memory;
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/tags");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/memory/tags", "POST", { id: mem.id, tags: ["linux"] }), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.ok, true);
+  assert.deepEqual(data.tags, ["linux"]);
+  assert.deepEqual(service.getMemoryTags(mem.id), ["linux"], "tag set persisted");
+});
+
+test("POST /api/dsh-mneme/memory/tags 409s when manualTagEnabled is off", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { manualTagEnabled: false } });
+  const settings = createSettings(store.db);
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, { add() {}, remove() {}, list() { return []; } });
+  const mem = service.saveWithDedupe({ type: "preference", title: "A", content: "x" }).memory;
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/tags");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/memory/tags", "POST", { id: mem.id, tags: ["x"] }), res);
+  assert.equal(res.statusCode, 409, "manual tag write rejected");
+  assert.match(JSON.parse(res.body).error, /manualTagEnabled/);
+  const get = new FakeRes();
+  await route.handler(req(`/api/dsh-mneme/memory/tags?id=${mem.id}`), get);
+  assert.equal(JSON.parse(get.body).manualTagEnabled, false, "GET reports the gate off");
+});
+
+// v0.6.3 directory view endpoint: /api/dsh-mneme/directory returns the
+// tag-grouped directory (groups + untagged) as JSON.
+test("GET /api/dsh-mneme/directory groups tagged memories by tag", async () => {
+  const { routes, service } = setup();
+  const a = service.saveWithDedupe({ type: "preference", title: "Linux", content: "内核" }).memory;
+  const b = service.saveWithDedupe({ type: "preference", title: "考研", content: "公共管理" }).memory;
+  service.setMemoryTags(a.id, ["linux"]);
+  service.setMemoryTags(b.id, ["考研"]);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/directory");
+  assert.ok(route, "directory route must be registered");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/directory"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.deepEqual(Object.keys(data).sort(), ["groups", "untagged"]);
+  assert.equal(data.groups.length, 2);
+  const linux = data.groups.find((g) => g.tag === "linux");
+  assert.deepEqual(linux.memories.map((m) => m.id), [a.id]);
+  assert.equal(linux.memories[0].title, "Linux");
+});
+
+test("GET /api/dsh-mneme/directory reports untagged memories", async () => {
+  const { routes, service } = setup();
+  const tagged = service.saveWithDedupe({ type: "preference", title: "Tagged", content: "x" }).memory;
+  const bare = service.saveWithDedupe({ type: "project", title: "Bare", content: "y" }).memory;
+  service.setMemoryTags(tagged.id, ["linux"]);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/directory");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/directory"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.deepEqual(data.untagged.map((m) => m.id), [bare.id]);
+});

package/test/boundary-v0625.test.js

@@ -0,0 +1,82 @@
+// v0.6.5 整合边界测试：跨 v0.6.1-0.6.4 的边界场景。
+// 覆盖：循环 wiki-link / 空 tag 清除 / 超长 tag 丢弃 / 多 tag 目录分组 /
+// autoTag 非法输出 fail-safe / tag 搜索大小写。
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { parseWikiLinks } from "../src/parser/wiki-link.js";
+import { parseTags } from "../src/parser/tag.js";
+import { extractQueryTags } from "../src/search/tag-boost.js";
+
+function makeService(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+test("wiki-link: mutual links (A→B and B→A) resolve without loops", () => {
+  const { store, service } = makeService({ wikiLinkEnabled: true });
+  const a = service.saveWithDedupe({
+    type: "preference", title: "Alpha", content: "参见 [[Beta]]", importance: 3,
+  }).memory;
+  const b = service.saveWithDedupe({
+    type: "preference", title: "Beta", content: "反链 [[Alpha]]", importance: 3,
+  }).memory;
+  store.saveWikiLinks({ memoryId: a.id, title: a.title, targets: ["Beta"] });
+  store.saveWikiLinks({ memoryId: b.id, title: b.title, targets: ["Alpha"] });
+  const ab = service.getForwardLinks(a.id);
+  const ba = service.getBacklinks(a.id);
+  assert.ok(ab.some((r) => r.target.id === b.id), "A links to B");
+  assert.ok(ba.some((r) => r.source.id === b.id), "B backlinks to A");
+  store.close();
+});
+
+test("tags: setting empty array clears the live tag row", () => {
+  const { store } = makeService();
+  const a = store.save({ type: "preference", title: "A", content: "c", tags: [] });
+  store.setMemoryTags(a.id, ["规划", "前端"]);
+  assert.deepEqual(store.getMemoryTags(a.id), ["规划", "前端"]);
+  store.setMemoryTags(a.id, []);
+  assert.deepEqual(store.getMemoryTags(a.id), []);
+  store.close();
+});
+
+test("parseTags: over-length and invalid tags are dropped", () => {
+  const out = parseTags("#短 #这是一个超过二十个字符的超级长标签 #ok_123 #带-连字符");
+  assert.ok(out.includes("短"), "short CJK tag kept");
+  assert.ok(out.includes("ok_123"), "alnum underscore kept");
+  assert.ok(out.includes("带-连字符"), "hyphen kept");
+  assert.ok(!out.some((t) => t.length > 20), "no tag exceeds 20 chars");
+});
+
+test("tag search: matches case-insensitively and composes with keywords", async () => {
+  const { store, service } = makeService();
+  const a = service.saveWithDedupe({
+    type: "preference", title: "规划", content: "博客重构", importance: 3,
+  }).memory;
+  store.setMemoryTags(a.id, ["规划"]);
+  const r = await service.searchMemories("tag:规划 博客", {
+    mode: "keyword", limit: 10, useRerank: false,
+  });
+  assert.ok(r.some((m) => m.id === a.id), "tag: prefix + keyword composition");
+  store.close();
+});
+
+test("directory: many-tag memory appears under every tag group", () => {
+  const { store, service } = makeService();
+  const a = store.save({ type: "preference", title: "多标签", content: "c", tags: [] });
+  store.setMemoryTags(a.id, ["规划", "前端", "博客"]);
+  const dir = store.getDirectory();
+  const groups = dir.groups.filter((g) => g.tag === "规划" || g.tag === "前端" || g.tag === "博客");
+  assert.equal(groups.length, 3, "one group per tag");
+  for (const g of groups) {
+    assert.ok(g.memories.some((m) => m.id === a.id), `memory under ${g.tag}`);
+  }
+  store.close();
+});
+
+test("extractQueryTags: known-tag mention is case-insensitive", () => {
+  const tags = extractQueryTags("PLANNING 进度", ["planning"]);
+  assert.deepEqual(tags, ["planning"]);
+});

package/test/client.test.js

@@ -268,3 +268,101 @@ test("detail content renders wiki-links and resolves them on click", () => {
     "the panel must render inside a .mneme-backlinks block"
   );
 });
+
+// v0.6.2 tag system: the detail pane renders tags as clickable chips wired to
+// the memory/tags endpoints, and a tag: query always goes server-side.
+test("detail pane renders editable tag chips backed by the tags endpoint", () => {
+  assert.ok(
+    clientSource.includes("/api/dsh-mneme/memory/tags?id="),
+    "the panel must fetch the selected memory's tags via the GET endpoint"
+  );
+  assert.ok(
+    clientSource.includes('method: "POST"'),
+    "adding/removing a tag must POST to the tags endpoint"
+  );
+  assert.ok(
+    clientSource.includes("onClick: () => onTagClick(tag)"),
+    "a tag chip click must trigger a tag: search"
+  );
+  assert.ok(
+    clientSource.includes("tagManual"),
+    "the panel must read the manualTagEnabled gate to hide editing"
+  );
+});
+
+test("tag: queries run server-side regardless of the semantic toggle", () => {
+  assert.ok(
+    clientSource.includes('(!semantic && !q.startsWith("tag:"))'),
+    "tag: must bypass the semantic toggle and use the search endpoint"
+  );
+  assert.ok(
+    clientSource.includes('setQuery(`tag:${tag}`)'),
+    "a tag chip click must set the query to tag:<tag>"
+  );
+});
+
+test("tag UI ships localized labels in both dictionaries", () => {
+  for (const key of ["tagAdd", "tagRemove", "tagPlaceholder", "tagsEmpty"]) {
+    assert.ok(
+      clientSource.includes(`"memory.explorer.${key}"`),
+      `memory.explorer.${key} key must exist`
+    );
+  }
+});
+
+// v0.6.3 directory view: a tag-folder tree backed by the directory endpoint.
+// Folders accordion via data-expanded controlled by MemoryExplorer-lifted
+// state; a memory entry click jumps back into the browser via onJump.
+test("directory sub-view mounts DirectoryPanel backed by the directory endpoint", () => {
+  assert.ok(
+    clientSource.includes("h(DirectoryPanel, { t, onJump: jumpToMemory, collapsed: dirCollapsed, setCollapsed: setDirCollapsed })"),
+    "the directory panel must be embedded as a sub-view with lifted collapse state"
+  );
+  assert.ok(
+    clientSource.includes("/api/dsh-mneme/directory"),
+    "DirectoryPanel must fetch the directory endpoint"
+  );
+  assert.ok(
+    clientSource.includes('className: "mneme-directory"'),
+    "the directory panel must render inside the .mneme-directory block"
+  );
+});
+
+test("directory folders accordion via data-expanded driven by MemoryExplorer state", () => {
+  assert.ok(
+    clientSource.includes('"data-expanded": String(open)'),
+    "folder expansion must be driven by the data-expanded attribute"
+  );
+  assert.ok(
+    clientSource.includes("const [dirCollapsed, setDirCollapsed] = useState({})"),
+    "collapse state must live in MemoryExplorer so tab switches keep it"
+  );
+  assert.ok(
+    clientSource.includes('"aria-expanded": String(open)'),
+    "folder headers must announce their expanded state"
+  );
+});
+
+test("directory entry click jumps to the memory detail via onJump", () => {
+  assert.ok(
+    clientSource.includes("onClick: () => onJump(m)"),
+    "clicking a memory entry must call onJump with the memory"
+  );
+  assert.ok(
+    clientSource.includes("formatDate(m.updated_at || m.created_at)"),
+    "entries must render a timestamp via formatDate"
+  );
+  assert.ok(
+    clientSource.includes("memory.directory.untagged"),
+    "untagged memories must be bucketed under a labeled fallback folder"
+  );
+});
+
+test("directory ships localized labels in both dictionaries", () => {
+  for (const key of ["memory.explorer.tabDirectory", "memory.directory.untagged", "memory.directory.loading", "memory.directory.empty"]) {
+    assert.ok(
+      clientSource.includes(`"${key}"`),
+      `${key} key must exist`
+    );
+  }
+});

package/test/directory.test.js

@@ -0,0 +1,134 @@
+// v0.6.3 目录视图测试。
+// 覆盖：store.getDirectory 按 tag 分组 / 组排序（tag 字典序）/
+// 组内成员排序（importance DESC → updated_at DESC）/
+// 无 tag 记忆进 untagged / disposed·archived·forgotten 过滤 /
+// 多 tag 记忆出现在每个 tag 文件夹 / service.getDirectory 输出 wire DTO。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+function seed(store, title, { importance = 3, type = "preference", tags, session_id } = {}) {
+  const mem = store.save({ type, title, content: `content of ${title}`, importance, session_id });
+  if (tags && tags.length) store.setMemoryTags(mem.id, tags);
+  return mem;
+}
+
+// Bump a row's updated_at directly so ordering assertions are deterministic
+// (nowIso() has ~ms resolution and a same-ms save loses the tiebreaker to the
+// random id).
+function setUpdatedAt(store, id, iso) {
+  store.db.prepare("UPDATE memories SET updated_at = ? WHERE id = ?").run(iso, id);
+}
+
+// ============================================================ grouping
+
+test("getDirectory groups live memories by their live tag set", () => {
+  const { store } = setup();
+  const a = seed(store, "Linux 笔记", { tags: ["linux"] });
+  const b = seed(store, "考研计划", { tags: ["考研"] });
+  const dir = store.getDirectory();
+  assert.equal(dir.groups.length, 2);
+  const linux = dir.groups.find((g) => g.tag === "linux");
+  const exam = dir.groups.find((g) => g.tag === "考研");
+  assert.deepEqual(linux.memories.map((m) => m.id), [a.id]);
+  assert.deepEqual(exam.memories.map((m) => m.id), [b.id]);
+  assert.deepEqual(dir.untagged, []);
+  store.close();
+});
+
+test("getDirectory sorts groups by tag (locale-aware)", () => {
+  const { store } = setup();
+  seed(store, "B", { tags: ["zebra"] });
+  seed(store, "A", { tags: ["alpha"] });
+  seed(store, "C", { tags: ["æon"] });
+  const dir = store.getDirectory();
+  const tags = dir.groups.map((g) => g.tag);
+  const sorted = [...tags].sort((x, y) => x.localeCompare(y));
+  assert.deepEqual(tags, sorted, "groups must come back tag-sorted");
+  store.close();
+});
+
+test("getDirectory orders group members by importance DESC then updated_at DESC", () => {
+  const { store } = setup();
+  // same importance → updated_at decides
+  const older = seed(store, "older", { tags: ["linux"], importance: 2 });
+  const newer = seed(store, "newer", { tags: ["linux"], importance: 2 });
+  setUpdatedAt(store, older.id, "2026-01-01T00:00:00.000Z");
+  setUpdatedAt(store, newer.id, "2026-08-01T00:00:00.000Z");
+  // higher importance wins regardless of age
+  const important = seed(store, "important", { tags: ["linux"], importance: 5 });
+  setUpdatedAt(store, important.id, "2025-01-01T00:00:00.000Z");
+  const dir = store.getDirectory();
+  const linux = dir.groups.find((g) => g.tag === "linux");
+  assert.deepEqual(
+    linux.memories.map((m) => m.id),
+    [important.id, newer.id, older.id],
+    "importance DESC primary, updated_at DESC secondary"
+  );
+  store.close();
+});
+
+test("getDirectory collects untagged memories and orders them identically", () => {
+  const { store } = setup();
+  const a = seed(store, "untagged one", { importance: 1 });
+  const b = seed(store, "untagged two", { importance: 4 });
+  seed(store, "tagged", { tags: ["linux"], importance: 3 });
+  const dir = store.getDirectory();
+  assert.deepEqual(dir.untagged.map((m) => m.id), [b.id, a.id], "importance DESC inside untagged");
+  assert.equal(dir.groups.some((g) => g.tag === "linux"), true);
+  store.close();
+});
+
+test("getDirectory excludes forgotten, archived and session-disposed memories", () => {
+  const { store } = setup();
+  const forgotten = seed(store, "forgotten", { tags: ["linux"] });
+  const archived = seed(store, "archived", { tags: ["linux"] });
+  const disposed = seed(store, "disposed", { tags: ["linux"], type: "summary", session_id: "sess-disposed" });
+  const keep = seed(store, "keep", { tags: ["linux"] });
+  store.setForget(forgotten.id, true);
+  store.setArchived(archived.id, true);
+  store.setDisposedBySession(disposed.session_id, true);
+  const dir = store.getDirectory();
+  const linux = dir.groups.find((g) => g.tag === "linux");
+  assert.deepEqual(linux.memories.map((m) => m.id), [keep.id], "only the live row survives");
+  assert.deepEqual(dir.untagged, []);
+  store.close();
+});
+
+test("getDirectory lists a multi-tag memory under every tag folder once each", () => {
+  const { store } = setup();
+  const multi = seed(store, "multi", { tags: ["linux", "bash"] });
+  const single = seed(store, "single", { tags: ["linux"] });
+  const dir = store.getDirectory();
+  const linux = dir.groups.find((g) => g.tag === "linux");
+  const bash = dir.groups.find((g) => g.tag === "bash");
+  // `single` is written second → newer updated_at → ranks before `multi`.
+  assert.deepEqual(linux.memories.map((m) => m.id), [single.id, multi.id]);
+  assert.deepEqual(bash.memories.map((m) => m.id), [multi.id]);
+  assert.equal(dir.untagged.length, 0);
+  store.close();
+});
+
+// ============================================================ service
+
+test("service.getDirectory returns the wire DTO shape with tags preserved", () => {
+  const { store, service } = setup();
+  const mem = seed(store, "笔记", { tags: ["linux"] });
+  seed(store, "裸条目", { importance: 2 });
+  const dir = service.getDirectory();
+  assert.deepEqual(Object.keys(dir).sort(), ["groups", "untagged"]);
+  const linux = dir.groups.find((g) => g.tag === "linux");
+  assert.equal(linux.memories[0].id, mem.id);
+  assert.equal(linux.memories[0].title, "笔记");
+  assert.equal(typeof linux.memories[0].updated_at, "string", "DTO carries updated_at for the entry row");
+  assert.equal(dir.untagged.length, 1);
+  assert.equal(dir.untagged[0].title, "裸条目");
+  store.close();
+});