@modusensus/dsh-mneme 0.6.0 → 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 (
@@ -552,6 +553,17 @@ export function createStore(path) {
   db.exec("PRAGMA journal_mode = WAL;");
   db.exec(SCHEMA);
 
+  // Wiki-link dedup (v0.6.1): a (from_entity, to_entity) pair is unique only for
+  // relation_type='links_to'. This is a PARTIAL index scoped to links_to, so the
+  // append-only semantics of all other relation types (uses/depends_on/part_of/
+  // related_to/supersedes — the extractor and autoDream write these per-run
+  // without global dedup, and supersedes rows carry distinct metadata like
+  // attr_key/old_value) are preserved. Idempotent (IF NOT EXISTS), atomic, and
+  // race-safe. Legacy DBs have no links_to rows yet, so the index builds cleanly
+  // everywhere and never breaks plugin startup (a full-table UNIQUE index would
+  // fail on legacy duplicates).
+  db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_relations_wikilink ON entity_relations(from_entity, to_entity, relation_type) WHERE relation_type = 'links_to'");
+
   // Schema migrations for legacy databases (idempotent). Each ADD COLUMN is
   // also race-safe: two concurrently-opening processes can both pass the
   // PRAGMA table_info check before either ALTERs, so the ALTER itself is
@@ -652,6 +664,19 @@ export function createStore(path) {
     return toRow(row);
   }
 
+  /**
+   * Case-insensitive exact title lookup (v0.6.1 wiki-link). COLLATE NOCASE
+   * folds ASCII case (CJK titles are inherently case-free, so they match
+   * verbatim). Returns the first matching memory or undefined. Best-effort —
+   * used by wiki-link target resolution and the read APIs.
+   */
+  function findByTitle(title) {
+    if (typeof title !== "string" || !title.trim()) return undefined;
+    return toRow(db.prepare(
+      "SELECT * FROM memories WHERE title = ? COLLATE NOCASE LIMIT 1"
+    ).get(title.trim()));
+  }
+
   function save(memory) {
     const id = memory.id ?? randomUUID();
     const type = memory.type;
@@ -1660,9 +1685,168 @@ 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.
+   * free-form JSON blob describing the relation. Relations are append-only —
+   * callers that need idempotency (e.g. wiki-links, via saveWikiLinks) guard
+   * with their own existence check plus the partial links_to unique index
+   * (idx_relations_wikilink) as a race backstop.
    */
   function saveRelation({ from_entity, to_entity, relation_type, memory_id, metadata }) {
     const id = randomUUID();
@@ -1676,7 +1860,56 @@ export function createStore(path) {
       `INSERT INTO entity_relations (id, from_entity, to_entity, relation_type, memory_id, created_at, metadata)
        VALUES (?, ?, ?, ?, ?, ?, ?)`
     ).run(id, from_entity, to_entity, relation_type, memory_id ?? null, now, metaStr);
-    return toRelation(db.prepare("SELECT * FROM entity_relations WHERE id = ?").get(id));
+    return toRelation(db.prepare(
+      "SELECT * FROM entity_relations WHERE from_entity = ? AND to_entity = ? AND relation_type = ? LIMIT 1"
+    ).get(from_entity, to_entity, relation_type));
+  }
+
+  /**
+   * Record wiki-link relations (v0.6.1). For each target title, resolve the
+   * target memory (case-insensitive title match via findByTitle) and write a
+   * links_to relation:
+   *   from_entity = source memory title, to_entity = canonical target memory
+   *   title, relation_type = 'links_to', memory_id = source memory id.
+   * Using the canonical resolved title keeps the graph case-consistent
+   * ([[beta]] and [[Beta]] collapse onto the same to_entity), so backlink
+   * lookups never fight the way a target was typed.
+   * Fail-safe: a target with no matching memory is skipped (never an error).
+   * Idempotent: an already-existing triple is a silent no-op (existence check
+   * here + the idx_relations_wikilink partial unique index as a race backstop),
+   * so `saved` only counts newly written relations. Returns { saved, skipped }.
+   */
+  function saveWikiLinks({ memoryId, title, targets }) {
+    const saved = [];
+    const skipped = [];
+    const seen = new Set(); // canonical (lowercased) targets already handled
+    const existsStmt = db.prepare(
+      "SELECT id FROM entity_relations WHERE from_entity = ? AND to_entity = ? AND relation_type = ?"
+    );
+    const list = Array.isArray(targets)
+      ? targets.filter((t) => typeof t === "string" && t.trim())
+      : [];
+    for (const raw of list) {
+      const target = raw.trim();
+      const key = target.toLowerCase();
+      if (seen.has(key)) continue; // dedupe within a single call (case-insensitive)
+      seen.add(key);
+      const targetMem = findByTitle(target);
+      if (!targetMem) {
+        skipped.push(target); // 目标不存在 → 跳过（Fail-safe）
+        continue;
+      }
+      const toEntity = targetMem.title;
+      if (existsStmt.get(title, toEntity, "links_to")) continue; // already linked → no-op
+      saved.push(saveRelation({
+        from_entity: title,
+        to_entity: toEntity,
+        relation_type: "links_to",
+        memory_id: memoryId,
+        metadata: { target_memory_id: targetMem.id }
+      }));
+    }
+    return { saved, skipped };
   }
 
   /**
@@ -1979,7 +2212,14 @@ export function createStore(path) {
     getAttrHistory,
     getAttrsByMemory,
     findMemoriesByAttr,
+    setMemoryTags,
+    getMemoryTags,
+    getMemoryTagsMap,
+    findMemoriesByTags,
+    getDirectory,
     saveRelation,
+    saveWikiLinks,
+    findByTitle,
     migrateAttrsToMemory,
     getRelations,
     setMirrorState,

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

@@ -232,3 +232,137 @@ test("explorer chrome aligns with the host design system", () => {
     "pill chips belong to the drawer era and must stay gone"
   );
 });
+
+// The v0.6.1 wiki-link feature: the detail pane mounts a BacklinksPanel that
+// fetches the two read-only link endpoints by the selected memory id and
+// renders back/forward rows, each jumping back into the browser.
+test("detail pane mounts a BacklinksPanel backed by the two link endpoints", () => {
+  assert.ok(
+    clientSource.includes("h(BacklinksPanel, { memory: selected, t, onJump: jumpToMemory })"),
+    "the detail pane must mount BacklinksPanel after the actions row"
+  );
+  assert.ok(
+    clientSource.includes("/api/dsh-mneme/wikilinks/backlinks?id="),
+    "BacklinksPanel must fetch the backlinks endpoint by memory id"
+  );
+  assert.ok(
+    clientSource.includes("/api/dsh-mneme/wikilinks/forward?id="),
+    "BacklinksPanel must fetch the forward-links endpoint by memory id"
+  );
+});
+
+// Detail content turns [[target]] / [[display|target]] into clickable links:
+// the display text survives, the target title is kept for hover, and a click
+// resolves the title through the resolve endpoint before jumping.
+test("detail content renders wiki-links and resolves them on click", () => {
+  assert.ok(
+    clientSource.includes('className: "mneme-wikilink"'),
+    "inline [[target]] links must use the .mneme-wikilink style"
+  );
+  assert.ok(
+    clientSource.includes("/api/dsh-mneme/wikilinks/resolve?title="),
+    "clicking a wiki-link must resolve the title via the resolve endpoint"
+  );
+  assert.ok(
+    clientSource.includes('className: "mneme-backlinks"'),
+    "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`
+    );
+  }
+});