@modusensus/dsh-mneme 0.6.1 → 0.6.6

package/README.md

@@ -116,7 +116,17 @@ dsh web
 
 **默认关闭**（`wikiLinkEnabled: false`）。开启后，记忆正文支持 `[[target]]` / `[[显示|target]]` 双括号链接语法：保存时自动解析并记录跨记忆 `links_to` 关系（partial 唯一索引只对 links_to 去重），记忆详情旁出现反向链接面板，点击可跳转来源记忆。提供只读 API：backlinks / forward-links / wikilink-resolve（输出脱敏）。
 
+### Tag 系统 🏷️（v0.6.2，opt-in）
 
+`autoTagEnabled` 默认关。开启后：正文 `#标签` 即时标记（规则 `[a-zA-Z0-9_一-龥-]+`，≤20 字符，非法/超长自动丢弃）；autoDream 整理后 LLM 自动打 1-3 个标签（`autoTagMaxPerRun=10` 频控，fail-safe）；tags 存 `entity_attrs`；`tag:` 搜索前缀可与关键词/`entity:`/`attr:` 组合；mirror 顶部渲染 `#tag` 行；记忆面板标签可点击（过滤）、添加、移除（`manualTagEnabled` 默认开）。存储与搜索能力始终可用，`autoTagEnabled` 只控制自动打标。
+
+### 目录视图 📁（v0.6.3）
+
+记忆面板新增「目录」视图：以 Tag 为轴心的一级手风琴文件夹，无标签记忆自动沉底到「无标签」兜底组；组内按重要性/时间双降序；点击条目直达详情页。数据由 `GET /api/dsh-mneme/directory` 提供（只读、排除 disposed/archived/forgotten）。
+
+### Tag 加权召回 ⚖️（v0.6.4，opt-in）
+
+`tagBoostEnabled` 默认关。开启后，三路召回合并出候选后做 tag 加权重排：候选记忆 tags 与 Query 提取 tags（`#xxx` + 已知 tag 列表）交集 → 分数 `×1.15`；与当前 Session 热记忆 tags 交集 → `×1.08`（可叠加，上限 1.0）。关闭时行为与旧版完全一致，可用 `evaluateRetrieval` 开关对比调优。
 
 官方设置面板 → 「记忆库设置」→「记忆」标签：按类型浏览、全文搜索；启用向量搜索后可用「语义」切换做向量召回。
 
@@ -216,6 +226,10 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 
 | 版本 | 亮点 |
 |------|------|
+| **v0.6.5** | 整合 v0.6.2-0.6.4：Tag 系统 + 目录视图 + Tag 加权召回（全部 opt-in）；709 测试全绿 |
+| **v0.6.4** | Tag 加权召回：query/session tag 交集 boost（`tagBoostEnabled` 默认关） |
+| **v0.6.3** | 目录视图：Tag 文件夹 + 无标签兜底 + 点击跳详情 |
+| **v0.6.2** | Tag 系统：`#标签` + autoDream 自动打标 + `tag:` 搜索 + 面板 chips |
 | **v0.6.1** | Wiki-Link 双向链接（笔记化记忆库第一步）：[[笔记]] 跨记忆链接 + 反向链接面板 + links_to partial 唯一索引；654 测试全绿 |
 | **v0.6.0** | 会话生命周期（把对话当存档点）：`session_disposed_at` 独立字段软隐藏会话删除的记忆（与 `archived` 正交，可恢复）+ `memory_delete` 支持描述删除 + 事件订阅熔断；阿里云 kimi-k2.7-code 审查 4 项修复；628 测试全绿 |
 | **v0.5.0** | 主区「记忆库」视图（取代侧边栏抽屉）+ 记忆图谱可视化（ego-graph API + 零依赖 SVG 力导向）+ BM25 三路召回融合 + 自适应阈值 + 会话热记忆 + 召回基准评测；593 测试全绿 |
@@ -245,6 +259,9 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 | **v0.5.0** | ✅ 完成 | 召回融合与记忆可视化 | 主区「记忆库」视图 + 记忆图谱（ego-graph API + 零依赖 SVG 力导向）+ BM25 三路召回融合 + 自适应阈值 + 会话热记忆 + 召回基准；593 测试全绿 |
 | **v0.6.0** | ✅ 完成 | 会话生命周期 | 把对话当存档点：`session_disposed_at` 软隐藏会话删除的记忆（与 `archived` 正交、可恢复）+ `memory_delete` 描述删除 + 事件熔断；628 测试全绿 |
 | **v0.6.1** | ✅ 完成 | Wiki-Link 双向链接 | 笔记化记忆库第一步：`[[target]]` 跨记忆链接 + 反向链接面板 + links_to partial 唯一索引；654 测试全绿 |
+| **v0.6.2** | ✅ 完成 | Tag 系统 | `#标签` 解析 + autoDream 自动打标 + `tag:` 搜索 + 面板 chips + mirror `#tag` 行（全部 opt-in） |
+| **v0.6.3** | ✅ 完成 | 目录视图 | Tag 文件夹手风琴 + 无标签兜底 + 点击跳详情 + `GET /api/dsh-mneme/directory` 端点 |
+| **v0.6.4** | ✅ 完成 | Tag 加权召回 | query/session tag 交集 boost（×1.15 / ×1.08），`tagBoostEnabled` 默认关 |
 | **v0.7.0+** | 🚀 远期 | 自进化记忆 | 兴趣漂移跟踪 + 跨 workspace 记忆共享（等 DSH 支持） |
 
 > 新能力一律做成**可开关的功能**（配置启用/关闭），默认保守开启、不破坏现有行为。`failure_memories` 表与 autoDream 决策引擎已为后续反思性成长铺好路。

package/lib/api.js

@@ -608,8 +608,84 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- memory tags (v0.6.2) ------------------------------------------------
+  // GET  /api/dsh-mneme/memory/tags?id=<memoryId> → live entity_attrs-backed
+  //       tag set for one memory plus the manualTagEnabled gate (so the panel
+  //       can hide tag editing when the manual path is off). Read-only, stays
+  //       open when apiToken is set (like list/search/semantic).
+  // POST /api/dsh-mneme/memory/tags { id, tags } → overwrite the live tag set
+  //       via service.setMemoryTags (manualTagEnabled gate); 409 when the gate
+  //       is closed. Auth-gated like the other write endpoints.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/memory/tags",
+    handler(req, res) {
+      try {
+        if (req.method === "POST" || req.method === "PUT") {
+          if (!requireAuth(req, res, apiToken)) return;
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            const id = typeof body.id === "string" ? body.id.trim() : "";
+            if (!id) {
+              sendJson(res, 400, { error: "missing-id" });
+              return;
+            }
+            const memory = service.getById?.(id) ?? null;
+            if (!memory) {
+              sendJson(res, 404, { error: "memory-not-found" });
+              return;
+            }
+            const result = service.setMemoryTags(id, Array.isArray(body.tags) ? body.tags : []);
+            if (result?.ok === false) {
+              sendJson(res, 409, { error: result.error || "tags-disabled" });
+              return;
+            }
+            sendJson(res, 200, { ok: true, memoryId: id, tags: result?.tags ?? [] });
+          });
+        }
+        const url = new URL(req.url, "http://localhost");
+        const id = (url.searchParams.get("id") ?? "").trim();
+        if (!id) {
+          sendJson(res, 400, { error: "missing-id" });
+          return;
+        }
+        const memory = service.getById?.(id) ?? null;
+        if (!memory) {
+          sendJson(res, 404, { error: "memory-not-found" });
+          return;
+        }
+        const tags = service.getMemoryTags?.(id) ?? [];
+        sendJson(res, 200, {
+          memoryId: id,
+          tags: Array.isArray(tags) ? tags : [],
+          manualTagEnabled: service.manualTagEnabled?.() ?? true
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- directory view (v0.6.3) ---------------------------------------------
+  // GET /api/dsh-mneme/directory → memories grouped by tag as
+  // { groups: [{ tag, memories: [...] }], untagged: [...] }. Live-only
+  // (forgotten/archived/session-disposed excluded), groups tag-sorted, members
+  // importance+updated DESC. Read-only, stays open when apiToken is set.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/directory",
+    handler(req, res) {
+      try {
+        const dir = service.getDirectory?.() ?? { groups: [], untagged: [] };
+        sendJson(res, 200, dir);
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   return {
-    routes: 11,
+    routes: 19,
     dispose: () => {
       for (const dispose of disposers) dispose();
     }

package/lib/client.js

@@ -88,6 +88,7 @@ window.__ModuleLoader__.load({
         "memory.overlay.close": "关闭",
         "memory.explorer.tabMemory": "记忆",
         "memory.explorer.tabGraph": "图谱",
+        "memory.explorer.tabDirectory": "目录",
         "memory.explorer.tabSettings": "设置",
         "memory.explorer.search": "搜索标题或内容…",
         "memory.explorer.searchTitle": "语义检索",
@@ -104,9 +105,16 @@ window.__ModuleLoader__.load({
         "memory.explorer.created": "创建",
         "memory.explorer.updated": "更新",
         "memory.explorer.tags": "标签",
+        "memory.explorer.tagAdd": "添加标签",
+        "memory.explorer.tagRemove": "移除标签",
+        "memory.explorer.tagPlaceholder": "输入标签，回车添加",
+        "memory.explorer.tagsEmpty": "暂无标签",
         "memory.explorer.importance": "重要性",
         "memory.explorer.topK": "返回数量",
         "memory.explorer.topKOption": "返回 {n} 条",
+        "memory.directory.untagged": "无标签",
+        "memory.directory.loading": "加载中…",
+        "memory.directory.empty": "暂无记忆条目",
         "memory.card.open": "在主区记忆库中查看全文",
         "memory.time.now": "刚刚",
         "memory.time.seconds": "{n}秒前",
@@ -180,6 +188,7 @@ window.__ModuleLoader__.load({
         "memory.overlay.close": "Close",
         "memory.explorer.tabMemory": "Memories",
         "memory.explorer.tabGraph": "Graph",
+        "memory.explorer.tabDirectory": "Directory",
         "memory.explorer.tabSettings": "Settings",
         "memory.explorer.search": "Search title or content…",
         "memory.explorer.searchTitle": "Semantic Search",
@@ -196,9 +205,16 @@ window.__ModuleLoader__.load({
         "memory.explorer.created": "Created",
         "memory.explorer.updated": "Updated",
         "memory.explorer.tags": "Tags",
+        "memory.explorer.tagAdd": "Add tag",
+        "memory.explorer.tagRemove": "Remove tag",
+        "memory.explorer.tagPlaceholder": "Type a tag, press Enter",
+        "memory.explorer.tagsEmpty": "No tags",
         "memory.explorer.importance": "Importance",
         "memory.explorer.topK": "Results limit",
         "memory.explorer.topKOption": "Return {n}",
+        "memory.directory.untagged": "Untagged",
+        "memory.directory.loading": "Loading…",
+        "memory.directory.empty": "No memories yet",
         "memory.card.open": "Open full text in the Memory tab",
         "memory.time.now": "just now",
         "memory.time.seconds": "{n}s ago",
@@ -299,6 +315,17 @@ window.__ModuleLoader__.load({
       ".mneme-hint{color:var(--dsw-alias-label-tertiary);padding:24px 0;text-align:center;font-size:13px}",
       ".mneme-entitychip{flex:none;height:26px;padding:0 10px;border-radius:8px;border:none;background:none;color:var(--dsw-alias-state-business-primary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;display:inline-flex;align-items:center}",
       ".mneme-entitychip:hover{background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
+      // --- tag chips in the detail meta (v0.6.2) ---
+      ".mneme-tagrow{display:flex;flex-wrap:wrap;gap:6px;align-items:center}",
+      ".mneme-tagchip{display:inline-flex;align-items:center;gap:4px;max-width:100%;height:22px;padding:0 4px 0 8px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-state-business-primary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px}",
+      ".mneme-tagchip:hover{background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
+      ".mneme-tagremove{flex:none;display:inline-flex;align-items:center;justify-content:center;width:14px;height:14px;border:none;border-radius:4px;background:none;color:var(--dsw-alias-label-tertiary);cursor:pointer;font-family:inherit;font-size:12px;line-height:1;padding:0}",
+      ".mneme-tagremove:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-tagadd{border:none;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;padding:2px 8px;border-radius:6px;flex:none}",
+      ".mneme-tagadd:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
+      ".mneme-taginput{box-sizing:border-box;height:22px;padding:0 8px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-label-primary);font-family:inherit;font-size:12px;outline:none;width:150px}",
+      ".mneme-taginput:focus{border-color:var(--dsw-alias-state-business-primary)}",
+      ".mneme-tagempty{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:16px}",
       // --- main-area memory library page ---
       ".mneme-x{flex:1;min-height:0;height:100%;width:100%;box-sizing:border-box;display:flex;flex-direction:column;background:var(--dsw-alias-bg-layer-1);--dsh-scrollbar-thumb:var(--dsw-alias-scrollbar-bg-l2);--dsh-scrollbar-thumb-hover:var(--dsw-alias-scrollbar-hover-l2)}",
       ".mneme-xbar{flex:none;display:flex;align-items:center;gap:6px;border-bottom:1px solid var(--dsw-alias-border-l2);padding:0 16px}",
@@ -379,6 +406,21 @@ window.__ModuleLoader__.load({
       ".mneme-gs-attrval{color:var(--dsw-alias-label-secondary);word-break:break-word;font-size:13px}",
       ".mneme-gs-link{display:block;width:100%;text-align:left;border:none;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;padding:3px 6px;border-radius:6px;word-break:break-word}",
       ".mneme-gs-link:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
+      // --- directory sub-view (v0.6.3): tag folders + memory entries ---
+      ".mneme-directory{flex:1;min-height:0;overflow-y:auto;padding:8px 10px 28px}",
+      ".mneme-dir-folder{margin-bottom:4px}",
+      ".mneme-dir-folderhead{display:flex;align-items:center;gap:6px;width:100%;padding:6px 8px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-primary);cursor:pointer;font-family:inherit;font-size:13px;font-weight:500;line-height:18px;text-align:left}",
+      ".mneme-dir-folderhead:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-dir-caret{flex:none;width:10px;text-align:center;color:var(--dsw-alias-label-tertiary);font-size:12px}",
+      ".mneme-dir-fname{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+      ".mneme-dir-fcount{flex:none;margin-left:auto;font-size:12px;line-height:16px;color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums}",
+      ".mneme-dir-fbody{margin:2px 0 4px 22px;padding-left:8px;border-left:1px solid var(--dsw-alias-border-l2)}",
+      ".mneme-dir-item{display:flex;gap:8px;align-items:baseline;width:100%;padding:4px 8px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;text-align:left}",
+      ".mneme-dir-item:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-dir-item.mneme-active{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary)}",
+      ".mneme-dir-ititle{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+      ".mneme-dir-itime{flex:none;font-size:12px;line-height:16px;color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums}",
+      ".mneme-dir-empty{color:var(--dsw-alias-label-tertiary);padding:24px 0;text-align:center;font-size:13px}",
       // --- settings sub-view ---
       ".mneme-xsettings{flex:1;min-height:0;overflow-y:auto;padding:24px 24px 48px}",
       ".mneme-xsettings-inner{max-width:640px}",
@@ -1068,10 +1110,86 @@ window.__ModuleLoader__.load({
       return tree;
     }
 
+    // --- directory sub-view (v0.6.3) ---
+    // A tag folder tree over the live memory set. One-level folders keyed by
+    // tag (handled on the server, getDirectory), each with a 二级 memory
+    // entry list (title + updated time); memories without a live tag land in
+    // the "untagged" folder. Collapse state lives in MemoryExplorer (lifted via
+    // `collapsed`), so switching tabs does not drop it. Clicking an entry jumps
+    // back into the browser with that memory selected (onJump = jumpToMemory).
+    function DirectoryPanel({ t, onJump, collapsed, setCollapsed }) {
+      const [dir, setDir] = useState(null); // { groups: [...], untagged: [...] }
+      const [status, setStatus] = useState("loading"); // loading | ready | error
+
+      useEffect(() => {
+        let cancelled = false;
+        setStatus("loading");
+        apiFetch("/api/dsh-mneme/directory")
+          .then((res) => (res.ok ? res.json() : null))
+          .then((d) => {
+            if (cancelled) return;
+            if (!d) { setDir(null); setStatus("error"); return; }
+            setDir({ groups: Array.isArray(d.groups) ? d.groups : [], untagged: Array.isArray(d.untagged) ? d.untagged : [] });
+            setStatus("ready");
+          })
+          .catch(() => { if (!cancelled) { setDir(null); setStatus("error"); } });
+        return () => { cancelled = true; };
+      }, []);
+
+      const toggle = (key) => setCollapsed((c) => ({ ...c, [key]: !c[key] }));
+
+      const renderFolder = (name, memories, extraKey, emptyLabel) => {
+        const folderKey = extraKey || name;
+        const open = !collapsed[folderKey];
+        const rows = memories.map((m) =>
+          h("button", {
+            key: m.id,
+            type: "button",
+            className: "mneme-dir-item",
+            onClick: () => onJump(m)
+          },
+            h("span", { className: "mneme-dir-ititle" }, m.title || m.content?.slice(0, 40)),
+            h("span", { className: "mneme-dir-itime" }, formatDate(m.updated_at || m.created_at))
+          )
+        );
+        return h("div", {
+          key: folderKey,
+          className: "mneme-dir-folder",
+          "data-expanded": String(open)
+        },
+          h("button", {
+            type: "button",
+            className: "mneme-dir-folderhead",
+            "aria-expanded": String(open),
+            onClick: () => toggle(folderKey)
+          },
+            h("span", { className: "mneme-dir-caret" }, open ? "▾" : "▸"),
+            h("span", { className: "mneme-dir-fname" }, name),
+            h("span", { className: "mneme-dir-fcount" }, String(memories.length))
+          ),
+          open && h("div", { className: "mneme-dir-fbody" },
+            rows.length > 0 ? rows : h("div", { className: "mneme-dir-empty" }, emptyLabel || t("memory.directory.empty"))
+          )
+        );
+      };
+
+      if (status === "loading") {
+        return h("div", { className: "mneme-directory" }, h("div", { className: "mneme-dir-empty" }, t("memory.directory.loading")));
+      }
+      const hasAny = dir && (dir.groups.length > 0 || dir.untagged.length > 0);
+      if (status === "error" || !hasAny) {
+        return h("div", { className: "mneme-directory" }, h("div", { className: "mneme-dir-empty" }, t("memory.directory.empty")));
+      }
+      return h("div", { className: "mneme-directory" },
+        dir.groups.map((g) => renderFolder(g.tag, g.memories)),
+        dir.untagged.length > 0 && renderFolder(t("memory.directory.untagged"), dir.untagged, "mneme-untagged")
+      );
+    }
+
     const EXPLORER_TYPES = ["preference", "project", "decision", "summary", "history"];
 
     function MemoryExplorer({ t }) {
-      const [view, setView] = useState("memory"); // memory | graph | settings
+      const [view, setView] = useState("memory"); // memory | directory | graph | settings
       const [items, setItems] = useState([]);
       const [loading, setLoading] = useState(true);
       const [type, setType] = useState("all");
@@ -1082,9 +1200,20 @@ window.__ModuleLoader__.load({
       const [remoteItems, setRemoteItems] = useState(null);
       const [selectedId, setSelectedId] = useState(null);
       const [collapsed, setCollapsed] = useState({});
+      // v0.6.3 directory sub-view: its own folder-collapse state, kept in
+      // MemoryExplorer so switching tabs does not lose it and jumpToMemory's
+      // time-tree reset (setCollapsed({})) cannot clobber it.
+      const [dirCollapsed, setDirCollapsed] = useState({});
       const [copied, setCopied] = useState(false);
       const [reloadKey, setReloadKey] = useState(0);
       const [graphFocus, setGraphFocus] = useState("");
+      // v0.6.2 tag editing state for the detail pane. The authoritative tag set
+      // lives server-side (entity_attrs), so it is fetched per selected memory
+      // and refreshed after every write instead of trusting the list snapshot.
+      const [tagTags, setTagTags] = useState([]);
+      const [tagManual, setTagManual] = useState(true);
+      const [tagInput, setTagInput] = useState("");
+      const [tagAdding, setTagAdding] = useState(false);
       const itemRefs = useRef(new Map());
 
       useEffect(() => {
@@ -1105,10 +1234,12 @@ window.__ModuleLoader__.load({
       }, [reloadKey]);
 
       // Semantic search: server-side ranking replaces the client filter
-      // while enabled and a query is present (debounced).
+      // while enabled and a query is present (debounced). tag: queries always
+      // go server-side (searchMemories resolves them without vector support),
+      // so they bypass the semantic toggle and use the same search endpoint.
       useEffect(() => {
         const q = query.trim();
-        if (!semantic || !q || q.startsWith("entity:")) { setRemoteItems(null); return; }
+        if ((!semantic && !q.startsWith("tag:")) || !q || q.startsWith("entity:")) { setRemoteItems(null); return; }
         let cancelled = false;
         const timer = setTimeout(() => {
           apiFetch(`/api/dsh-mneme/search?q=${encodeURIComponent(q)}&mode=vector&topK=${searchTopK}`)
@@ -1124,6 +1255,30 @@ window.__ModuleLoader__.load({
         itemRefs.current.get(selectedId)?.scrollIntoView({ block: "nearest" });
       }, [selectedId]);
 
+      // Load the authoritative tag set for the selected memory (entity_attrs-
+      // backed) plus the manualTagEnabled gate that hides editing when off.
+      const loadTags = (id) => {
+        if (!id) { setTagTags([]); setTagManual(true); setTagInput(""); return; }
+        apiFetch(`/api/dsh-mneme/memory/tags?id=${encodeURIComponent(id)}`)
+          .then((res) => (res.ok ? res.json() : null))
+          .then((j) => { if (j) { setTagTags(Array.isArray(j.tags) ? j.tags : []); setTagManual(j.manualTagEnabled !== false); } })
+          .catch(() => {});
+      };
+      useEffect(() => {
+        let cancelled = false;
+        if (selectedId) {
+          apiFetch(`/api/dsh-mneme/memory/tags?id=${encodeURIComponent(selectedId)}`)
+            .then((res) => (res.ok ? res.json() : null))
+            .then((j) => { if (!cancelled && j) { setTagTags(Array.isArray(j.tags) ? j.tags : []); setTagManual(j.manualTagEnabled !== false); } })
+            .catch(() => {});
+        } else {
+          setTagTags([]);
+          setTagManual(true);
+        }
+        setTagAdding(false);
+        return () => { cancelled = true; };
+      }, [selectedId]);
+
       const q = query.trim().toLowerCase();
       // "entity:" is the graph entry grammar: typing it means the user wants
       // the entity's neighborhood, not a memory list. Offer the jump instead
@@ -1183,6 +1338,42 @@ window.__ModuleLoader__.load({
         );
       };
 
+      // v0.6.2 tag editing: a chip click jumps to a tag:xxx search (reusing
+      // the query-driven search flow), the + entry and per-chip × post the new
+      // tag set through the tags endpoint then re-fetch. A 409 from the server
+      // means manualTagEnabled turned off — flip the gate so editing hides.
+      const submitTag = () => {
+        const tag = tagInput.trim();
+        if (!tag || !selectedId) return;
+        apiFetch("/api/dsh-mneme/memory/tags", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ id: selectedId, tags: [...tagTags, tag] })
+        }).then((res) => {
+          if (res.status === 409) { setTagManual(false); setTagAdding(false); setTagInput(""); return; }
+          return res.json();
+        }).then((j) => {
+          if (j?.ok) { setTagAdding(false); setTagInput(""); loadTags(selectedId); }
+        }).catch(() => {});
+      };
+      const removeTag = (tag) => {
+        if (!selectedId) return;
+        apiFetch("/api/dsh-mneme/memory/tags", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ id: selectedId, tags: tagTags.filter((x) => x !== tag) })
+        }).then((res) => {
+          if (res.status === 409) { setTagManual(false); return; }
+          return res.json();
+        }).then((j) => {
+          if (j?.ok) loadTags(selectedId);
+        }).catch(() => {});
+      };
+      const onTagClick = (tag) => {
+        setType("all");
+        setQuery(`tag:${tag}`);
+      };
+
       // Graph → memory jump: land on the browser tab with filters reset so
       // the target row is visible, selected and scrolled into view.
       const jumpToMemory = (target) => {
@@ -1212,6 +1403,7 @@ window.__ModuleLoader__.load({
 
       const subviews = [
         { key: "memory", label: t("memory.explorer.tabMemory") },
+        { key: "directory", label: t("memory.explorer.tabDirectory") },
         { key: "graph", label: t("memory.explorer.tabGraph") },
         { key: "settings", label: t("memory.explorer.tabSettings") }
       ];
@@ -1293,8 +1485,44 @@ window.__ModuleLoader__.load({
                         h("span", { title: formatDate(selected.created_at) }, `${t("memory.explorer.created")}: ${formatDate(selected.created_at)}`),
                         h("span", { title: formatDate(selected.updated_at) }, `${t("memory.explorer.updated")}: ${formatDate(selected.updated_at)}`)
                       ),
-                      Array.isArray(selected.tags) && selected.tags.length > 0 && h("div", { className: "mneme-xdmeta" },
-                        h("span", null, `${t("memory.explorer.tags")}: ${selected.tags.join(" · ")}`)
+                      h("div", { className: "mneme-xdmeta" },
+                        h("span", null, t("memory.explorer.tags")),
+                        h("div", { className: "mneme-tagrow" },
+                          tagTags.length > 0
+                            ? tagTags.map((tag) =>
+                                h("span", {
+                                  key: tag,
+                                  className: "mneme-tagchip",
+                                  title: `tag:${tag}`,
+                                  onClick: () => onTagClick(tag)
+                                },
+                                  tag,
+                                  tagManual && h("button", {
+                                    type: "button",
+                                    className: "mneme-tagremove",
+                                    "aria-label": `${t("memory.explorer.tagRemove")}: ${tag}`,
+                                    onClick: (e) => { e.stopPropagation(); removeTag(tag); }
+                                  }, "×")
+                                )
+                              )
+                            : h("span", { className: "mneme-tagempty" }, t("memory.explorer.tagsEmpty")),
+                          tagManual && (tagAdding
+                            ? h("input", {
+                                key: selectedId,
+                                className: "mneme-taginput",
+                                autoFocus: true,
+                                value: tagInput,
+                                placeholder: t("memory.explorer.tagPlaceholder"),
+                                onChange: (e) => setTagInput(e.target.value),
+                                onKeyDown: (e) => { if (e.key === "Enter") submitTag(); },
+                                onBlur: () => { setTagAdding(false); setTagInput(""); }
+                              })
+                            : h("button", {
+                                type: "button",
+                                className: "mneme-tagadd",
+                                onClick: () => setTagAdding(true)
+                              }, `+ ${t("memory.explorer.tagAdd")}`))
+                        )
                       ),
                       h("div", { className: "mneme-xdcontent" },
                         selected.content ? wikilinkSegments(selected.content, onWikilinkClick) : selected.content
@@ -1354,6 +1582,7 @@ window.__ModuleLoader__.load({
             )
           )
         ),
+        view === "directory" && h(DirectoryPanel, { t, onJump: jumpToMemory, collapsed: dirCollapsed, setCollapsed: setDirCollapsed }),
         view === "graph" && h(GraphPanel, { t, focusEntity: graphFocus, onJumpMemory: jumpToMemory }),
         view === "settings" && h("div", { className: "mneme-xsettings" },
           h("div", { className: "mneme-xsettings-inner" }, h(SettingsContent, { t }))

package/lib/config.js

@@ -175,6 +175,24 @@ export const Config = z.object({
   // regardless of this flag.
   wikiLinkEnabled: z.boolean().default(false),
 
+  // --- tag system (v0.6.2) ---------------------------------------------------
+  // Opt-in: when autoTagEnabled is true, a light LLM pass runs after each
+  // autoDream consolidation and extracts 1-3 tags per retained memory
+  // (autoTagMaxPerRun bounds how many memories are tagged per run). The tag
+  // storage layer (store.setMemoryTags/getMemoryTags + tag: search + mirror
+  // `#tag` line) is always available regardless of this flag.
+  autoTagEnabled: z.boolean().default(false),
+  autoTagMaxPerRun: z.natural().min(1).max(100).default(10),
+  // Manual tagging (service.setMemoryTags / memory tools) is on by default;
+  // set false to disable the manual write path too.
+  manualTagEnabled: z.boolean().default(true),
+
+  // --- tag-weighted re-rank (v0.6.4) -------------------------------------
+  // Opt-in: boost candidates whose tags overlap the query/session tags.
+  tagBoostEnabled: z.boolean().default(false),
+  tagBoostFactor: z.number().min(1).max(2).default(1.15),
+  sessionTagBoostFactor: z.number().min(1).max(2).default(1.08),
+
   // --- sleep mode: idle-triggered deep maintenance (v0.4.0) ---------------
   // Opt-in, off by default. Unlike autoDream (threshold-triggered, lightweight)
   // sleep fires when the store has been quiet for sleepIdleMinutes and deep-

package/lib/dream/tag-extractor.js

@@ -0,0 +1,156 @@
+// v0.6.2 auto-tag: a lightweight LLM pass that runs after an autoDream
+// consolidation and extracts 1-3 tags per retained memory. Opt-in via
+// config.autoTagEnabled (default false); autoTagMaxPerRun (default 10) bounds
+// how many memories are tagged per run.
+//
+// Design notes:
+//   - ONE batched LLM call per run (the consolidation route is reused). Each
+//     memory is a prompt line; the model replies with a JSON array of
+//     {"id","tags"} entries — the per-memory contract is `{"tags":[...]}`.
+//   - Fail-safe everywhere: a missing route / aborted stream / unparseable
+//     JSON / unknown id / illegal tag are all skipped, never thrown. Tagging
+//     must never degrade the consolidation run it rides on.
+//   - The actual writes go through service.applyMemoryTags inside a
+//     service.transaction, so the mirror re-renders exactly once per pass and
+//     the write hooks fire once (never per memory).
+import { sanitizeTags, MAX_TAG_LENGTH } from "../parser/tag.js";
+
+const TAG_PROMPT = `你是记忆库标签助手。下面是保留的记忆条目（id、标题、内容）。
+对每条记忆提取 1-3 个中文或英文标签，用于检索分类。
+标签规则：
+- 只允许字符：字母、数字、下划线、中文、连字符（如：linux、考研、deepseek-r1）
+- 标签长度 ≤ ${MAX_TAG_LENGTH} 字符
+- 宁缺毋滥：提取最核心的 1-3 个，不要凑数
+- 不要输出内容里没有依据的标签
+只输出一个 JSON 数组，每项形如 { "id": "<记忆id>", "tags": ["标签1", "标签2"] }。
+不要输出其他文字。`;
+
+/** Same stream consumption contract as dream.js. Returns accumulated text or
+ *  undefined when the stream aborted/errored. */
+async function streamText(ctx, options) {
+  if (!ctx?.llm?.stream) return undefined;
+  let text = "";
+  for await (const chunk of ctx.llm.stream(options)) {
+    if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
+    if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
+      return undefined;
+    }
+  }
+  return text;
+}
+
+/** Pull the outermost JSON array out of a model reply (same tolerant contract
+ *  as sleep.js parseJsonArray): find the first `[` … last `]` and parse. */
+function parseJsonArray(text) {
+  if (typeof text !== "string") return undefined;
+  const start = text.indexOf("[");
+  const end = text.lastIndexOf("]");
+  if (start === -1 || end <= start) return undefined;
+  try {
+    const parsed = JSON.parse(text.slice(start, end + 1));
+    return Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Resolve the LLM route for the tag pass: the caller-provided consolidation
+ *  route first, then dreamProvider/dreamModel. Falls through to undefined. */
+function resolveTagRoute(route, config, logger) {
+  if (route?.provider && route?.model) return route;
+  if (config?.dreamProvider && config?.dreamModel) return { provider: config.dreamProvider, model: config.dreamModel };
+  logger?.warn?.("dsh-mneme auto-tag: no llm route available");
+  return undefined;
+}
+
+/**
+ * Run the auto-tag pass over retained memories.
+ * @param {object} opts
+ * @param {object} opts.ctx        — { llm, logger }
+ * @param {object} opts.service    — service handle (all/transaction/applyMemoryTags)
+ * @param {object} opts.config     — plugin config (autoTagMaxPerRun, dreamProvider…)
+ * @param {object} [opts.route]    — already-resolved consolidation route
+ * @returns {Promise<{ok: boolean, tagged: number, skipped: number, failed: number, skippedBy: boolean}>}
+ */
+export async function runAutoTag({ ctx, service, config, route }) {
+  const logger = ctx?.logger;
+  const maxPerRun = Number.isInteger(config?.autoTagMaxPerRun) && config.autoTagMaxPerRun > 0
+    ? config.autoTagMaxPerRun
+    : 10;
+  // Retained = post-consolidation active memories, newest first, capped.
+  // Skip memories that already carry live tags — otherwise every run re-picks
+  // the same "newest" batch (tagging doesn't bump updated_at) and older
+  // memories starve; manual tags are also left untouched this way.
+  const memories = service.all()
+    .filter((m) => !m.forgotten && !m.archived && !m.session_disposed_at && m.type !== "summary")
+    .filter((m) => (service.getMemoryTags?.(m.id) ?? []).length === 0)
+    .sort((a, b) => {
+      const ta = String(a.updated_at ?? "");
+      const tb = String(b.updated_at ?? "");
+      if (ta < tb) return 1;
+      if (ta > tb) return -1;
+      return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    })
+    .slice(0, Math.max(1, maxPerRun));
+  if (!memories.length) return { ok: true, tagged: 0, skipped: 0, failed: 0, skippedBy: "empty" };
+  const tagRoute = resolveTagRoute(route, config, logger);
+  if (!tagRoute) return { ok: false, tagged: 0, skipped: memories.length, failed: 0, skippedBy: "no-route" };
+
+  const listText = memories
+    .map((m) => `id=${m.id} | title=${m.title} | content=${m.content}`)
+    .join("\n");
+  const text = await streamText(ctx, {
+    provider: tagRoute.provider,
+    model: tagRoute.model,
+    purpose: "compaction",
+    maxTokens: Math.min(2048, config?.dreamMaxTokens ?? 2048),
+    messages: [
+      { role: "system", content: [{ type: "text", text: TAG_PROMPT }] },
+      { role: "user", content: [{ type: "text", text: listText }] }
+    ]
+  });
+  if (text === undefined) return { ok: false, tagged: 0, skipped: memories.length, failed: 0, skippedBy: "llm-failed" };
+
+  const entries = parseJsonArray(text);
+  if (!entries) {
+    logger?.warn?.("dsh-mneme auto-tag: no json array in llm output");
+    return { ok: false, tagged: 0, skipped: memories.length, failed: 0, skippedBy: "bad-json" };
+  }
+
+  // Validate ids against the candidate set (unknown ids are ignored, never
+  // written — a stray id could otherwise tag an unrelated memory).
+  const candidateIds = new Set(memories.map((m) => m.id));
+  const toWrite = [];
+  let skipped = 0;
+  let failed = 0;
+  const seenIds = new Set();
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") { failed++; continue; }
+    const id = typeof entry.id === "string" ? entry.id : undefined;
+    if (!id || !candidateIds.has(id)) { failed++; continue; }
+    if (seenIds.has(id)) continue; // first entry per id wins
+    seenIds.add(id);
+    // Reuse the shared sanitizer: strip, ≤20 chars, drop illegal, dedupe.
+    const tags = sanitizeTags(entry.tags);
+    if (!tags.length) { skipped++; continue; }
+    toWrite.push({ id, tags });
+  }
+
+  // Write the whole batch under one transaction: mirror re-renders once.
+  let tagged = 0;
+  try {
+    service.transaction(() => {
+      for (const { id, tags } of toWrite) {
+        // Merge with existing live tags (never clobber manual tags that landed
+        // between selection and write).
+        const existing = service.getMemoryTags?.(id) ?? [];
+        service.applyMemoryTags(id, [...new Set([...existing, ...tags])]);
+        tagged++;
+      }
+    });
+  } catch (error) {
+    logger?.warn?.(`dsh-mneme auto-tag: write failed: ${String(error)}`);
+    return { ok: false, tagged, skipped, failed, skippedBy: "write-failed" };
+  }
+  return { ok: true, tagged, skipped, failed, skippedBy: false };
+}