@modusensus/dsh-mneme 0.5.3 → 0.6.1

package/README.md

@@ -5,7 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Awesome](https://awesome-dsh-plugin.com/badge.svg)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-603%20passed-success)](https://github.com/modusensus/dsh-mneme)
+[![tests](https://img.shields.io/badge/tests-628%20passed-success)](https://github.com/modusensus/dsh-mneme)
 
 > 给 DeepSeek Harness 的跨会话记忆插件：让 Agent 记住你、记住项目、自动整理记忆。**Mneme**（Μνήμη）——希腊记忆女神 Mnemosyne 之名，掌管记忆与梦境，正如 autoDream 在后台巩固记忆。
 
@@ -30,6 +30,7 @@ dsh web
 - 不是向量数据库——语义搜索是可选增强，默认零额外依赖
 - 不替代会话日志——它存的是「值得跨会话记住的」精炼知识
 - 不改变模型本身——进化的是记忆库与每次注入的上下文
+- 删对话 ≠ 删记忆——开启会话生命周期后，删除会话只是把该会话出生的记忆**软隐藏**（可恢复），数据不丢
 
 ## ✨ 功能
 
@@ -52,7 +53,7 @@ dsh web
 | `memory_search` | 全文搜索（中文子串友好，可启用向量语义搜索） |
 | `memory_list` | 按类型分页列出（`include_archived=true` 可查看已归档） |
 | `memory_update` | 修改已有记忆 |
-| `memory_delete` | 删除记忆 |
+| `memory_delete` | 删除记忆（v0.6.0 支持 `query` 按描述删除，不只能靠记忆 ID） |
 | `memory_forget` | 抑制注入（降权不删除，可恢复） |
 | `memory_archive` | 归档/恢复记忆（v0.2.5；归档后隐藏于列表/搜索/注入/整理，`archived=false` 可恢复） |
 
@@ -102,7 +103,20 @@ dsh web
 
 > 配置详见 `docs/SLEEP.md`；迁移说明见 `docs/MIGRATION.md`。
 
-### Web 记忆面板
+### 会话生命周期：把对话当存档点 💾（v0.6.0，opt-in）
+
+**默认关闭**（`sessionLifecycleEnabled: false`，保持旧行为）。开启后，会话被删除/销毁（DSH `session/disposed` 事件）时，自动把该会话内出生（`session_id` 溯源）的记忆**软隐藏**——不再出现在检索/注入/列表/整理，但**不删除**，随时可恢复：
+
+- **与 `archived` 正交**：`archived` 是用户/AI 主动"长期保留但安静"，`session_disposed_at` 是会话删除被动隔离，两者互不覆盖。恢复会话绝不复活你手动归档的记忆
+- **全局记忆免疫**：存量无 `session_id` 的记忆视为全局，永不参与会话清理
+- **幂等 + 熔断**：dispose/restore 状态守卫幂等（重复调用 no-op）；事件回调内部异常 catch 住，不抛进 DSH 会话清理流程
+- **恢复**：整会话 `service.restoreBySession(sessionId)` 一键还原；`service.listBySession(sessionId, { includeDisposed: true })` 可查看当前隐藏了哪些（DTO 带 `disposed` 标记）
+
+### Wiki-Link 双向链接 🔗（v0.6.1，opt-in）
+
+**默认关闭**（`wikiLinkEnabled: false`）。开启后，记忆正文支持 `[[target]]` / `[[显示|target]]` 双括号链接语法：保存时自动解析并记录跨记忆 `links_to` 关系（partial 唯一索引只对 links_to 去重），记忆详情旁出现反向链接面板，点击可跳转来源记忆。提供只读 API：backlinks / forward-links / wikilink-resolve（输出脱敏）。
+
+
 
 官方设置面板 → 「记忆库设置」→「记忆」标签：按类型浏览、全文搜索；启用向量搜索后可用「语义」切换做向量召回。
 
@@ -202,6 +216,8 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 
 | 版本 | 亮点 |
 |------|------|
+| **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 测试全绿 |
 | **v0.4.2** | autoSummarize 自定义模型：`summarizeProvider`/`summarizeModel` 配置项，可独立指定轻量模型（如 qwen3.6-plus）用于会话摘要，节省主模型 token；473 测试全绿 |
 | **v0.4.0** | 系统级睡眠 Sleep Mode：空闲触发的四阶段深度维护（冲突消解 / 归档降级 / 模式发现 / 关系补全），可中断、串行安全、fail-safe，分层压缩释放冷记忆；471 测试全绿 |
@@ -227,7 +243,9 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 | **v0.4.6** | ✅ 完成 | 8 项修复（向量链路 + 注入/质量/审计） | 向量链路修复（embedSingle 适配 / `autoReindexOnBoot` 存量回填 / `vector_meta` 元数据）+ 注入语义召回 `hybridInject` + 同标题追加 `content_history` + 注入长度上限（单条 300 / 整块 1500）+ 记忆质量过滤 `memoryQualityFilter` + LLM 消耗审计 `llmAudit`（表 + 埋点 + 只读 API）；553 测试全绿 |
 | **v0.4.7** | ✅ 完成 | schema 迁移幂等化 | 并发打开同一 db 时 `PRAGMA table_info` 检查与 ALTER 非原子，可能重复 `ADD COLUMN` 报 duplicate column name；改用 `addColumn` helper 吞掉竞态（try/catch），12 处迁移统一收口 |
 | **v0.5.0** | ✅ 完成 | 召回融合与记忆可视化 | 主区「记忆库」视图 + 记忆图谱（ego-graph API + 零依赖 SVG 力导向）+ BM25 三路召回融合 + 自适应阈值 + 会话热记忆 + 召回基准；593 测试全绿 |
-| **v0.6.0+** | 🚀 远期 | 自进化记忆 | 兴趣漂移跟踪 + 跨 workspace 记忆共享（等 DSH 支持） |
+| **v0.6.0** | ✅ 完成 | 会话生命周期 | 把对话当存档点：`session_disposed_at` 软隐藏会话删除的记忆（与 `archived` 正交、可恢复）+ `memory_delete` 描述删除 + 事件熔断；628 测试全绿 |
+| **v0.6.1** | ✅ 完成 | Wiki-Link 双向链接 | 笔记化记忆库第一步：`[[target]]` 跨记忆链接 + 反向链接面板 + links_to partial 唯一索引；654 测试全绿 |
+| **v0.7.0+** | 🚀 远期 | 自进化记忆 | 兴趣漂移跟踪 + 跨 workspace 记忆共享（等 DSH 支持） |
 
 > 新能力一律做成**可开关的功能**（配置启用/关闭），默认保守开启、不破坏现有行为。`failure_memories` 表与 autoDream 决策引擎已为后续反思性成长铺好路。
 
@@ -280,6 +298,8 @@ dsh web
     dreamThresholdCount: 10
     dreamThresholdChars: 5000
     dreamDelayMs: 2000
+    # 会话生命周期（v0.6.0，默认关）：会话被删时软隐藏其记忆，可恢复
+    # sessionLifecycleEnabled: false
 ```
 
 ## ⚙️ 配置
@@ -342,6 +362,7 @@ dsh web
 | `searchSemanticDedupThreshold` | `0.95` | 语义去重相似度阈值（v0.5.0，默认 0.95，范围 0.5-1.0）：`searchSemanticDedup=true` 时生效，调整可防小模型误折叠 |
 | `memoryQualityFilter` | `{enabled:true, archiveThreshold:30, degradeThreshold:60, minContentLength:10}` | 记忆质量过滤（v0.4.6，默认开）：写库前启发式打分 0-100，元记忆词汇/自指/过短/重复/近似重复扣分；≥60 正常存储，30-60 降权（注入排序按 importance×quality/100），<30 归档标记 `low_quality`（显式搜索仍可召回，永不自动注入） |
 | `llmAudit` | `{enabled:true, retentionDays:90}` | LLM 消耗审计（v0.4.6，默认开）：每次后台 LLM 调用（autoDream/autoSummarize）写 `llm_audit_logs`（tokens/duration/status/source）；失败记 error 不阻塞；只读 API `/api/dsh-mneme/semantic/llm-audit` + `/llm-audit/stats` |
+| `sessionLifecycleEnabled` | `false` | 会话生命周期（v0.6.0，默认关）：开启后会话被删除/销毁时自动把该会话出生的记忆软隐藏（`session_disposed_at`，与 `archived` 正交、可恢复）；存量无 `session_id` 的记忆永不参与清理 |
 
 > 🔐 **API 安全**：DSH 无内置鉴权且默认仅监听 `127.0.0.1`。插件 API 默认开放（便于 Web 面板即装即用）。如需防护（如局域网暴露），在配置中设置 `apiToken`：写操作（画像/规则/命令）与密钥端点（`vector-config`、`vector-reindex`）需携带 `Authorization: Bearer <token>`（前端设置面板可填入同一 token），只读的 `list` / `search` / `semantic` 保持开放。`/api/dsh-mneme/vector-config` 返回的 `apiKey` 已掩码（`sk-***…`），存储仍保留明文供调用；前端回传空或掩码值表示"不改 key"。
 
@@ -387,7 +408,7 @@ src/
 lib/
 ├── client.js         # Web 面板（手写 ModuleLoader bundle）
 └── *.js              # src 的同步分发产物
-test/                 # 603 个 node:test 测试（含审计与三轴线压测不变量）
+test/                 # 628 个 node:test 测试（含审计与三轴线压测不变量）
 scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压测 · sync-lib.js 同步 · benchmark-recall.js 召回基准
 ```
 
@@ -396,7 +417,7 @@ scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 603 个测试
+npm test           # 运行 628 个测试
 npm run stress     # 三轴线压测：长会话检索 / 冲突仲裁 / 多 Agent 并发（离线 mock LLM）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```

package/lib/api.js

@@ -422,6 +422,107 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- wiki-link back links (v0.6.1) --------------------------------------
+  // Read-only like the graph endpoints, so it stays open when apiToken is set.
+  // GET /api/dsh-mneme/wikilinks/backlinks?id=<memoryId> → memories whose
+  // content carries a [[wiki-link]] resolving to the given memory.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/wikilinks/backlinks",
+    handler(req, res) {
+      try {
+        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;
+        const backlinks = (service.getBacklinks?.(id) ?? []).map(({ source, relation }) => ({
+          id: source.id,
+          title: source.title,
+          type: source.type,
+          created_at: relation.created_at
+        }));
+        sendJson(res, 200, {
+          memoryId: id,
+          memory: memory ? { id: memory.id, title: memory.title, type: memory.type } : null,
+          backlinks
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- wiki-link forward links (v0.6.1) -----------------------------------
+  // GET /api/dsh-mneme/wikilinks/forward?id=<memoryId> → memories the given
+  // memory explicitly links to. Unresolved target titles surface with id:null.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/wikilinks/forward",
+    handler(req, res) {
+      try {
+        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;
+        const links = (service.getForwardLinks?.(id) ?? []).map(({ target, relation }) => ({
+          id: target?.id ?? null,
+          title: target?.title ?? relation.to_entity,
+          type: target?.type ?? null,
+          created_at: relation.created_at
+        }));
+        sendJson(res, 200, {
+          memoryId: id,
+          memory: memory ? { id: memory.id, title: memory.title, type: memory.type } : null,
+          links
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- wiki-link resolve (v0.6.1) -----------------------------------------
+  // GET /api/dsh-mneme/wikilinks/resolve?title=<title> → case-insensitive exact
+  // title match against the memories table (the resolution used when writing
+  // links_to relations). 404 when no memory matches.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/wikilinks/resolve",
+    handler(req, res) {
+      try {
+        const url = new URL(req.url, "http://localhost");
+        const title = (url.searchParams.get("title") ?? "").trim();
+        if (!title) {
+          sendJson(res, 400, { error: "missing-title" });
+          return;
+        }
+        const memory = service.resolveWikiLink?.(title) ?? null;
+        if (!memory) {
+          sendJson(res, 404, { error: "memory-not-found", title });
+          return;
+        }
+        // Note: no `source` field — it may carry file paths/internal host info
+        // and this endpoint is read-only without auth when apiToken is set.
+        sendJson(res, 200, {
+          title,
+          memory: {
+            id: memory.id,
+            title: memory.title,
+            type: memory.type
+          }
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- health: mirror sync state (F-NEW-03 / v0.3.6) ---
   // Auth-gated; only returns a sanitized error code (never raw last_error which
   // may leak paths/token-like strings/internal hosts). On state read failure it

package/lib/client.js

@@ -142,7 +142,12 @@ window.__ModuleLoader__.load({
         "memory.settings.apiTokenHint": "设置后，写操作与密钥接口（画像/规则/命令/向量配置）需携带 Authorization: Bearer <token>；面板只读操作不受影响。清空并保存可关闭鉴权。",
         "memory.settings.apiTokenPlaceholder": "留空 = 不鉴权（默认）",
         "memory.settings.apiTokenSave": "保存 Token",
-        "memory.settings.apiTokenSaved": "Token 已保存"
+        "memory.settings.apiTokenSaved": "Token 已保存",
+        "memory.wikilink.backlinks": "链接到此记忆",
+        "memory.wikilink.forward": "此记忆链接到",
+        "memory.wikilink.empty": "暂无关联记忆",
+        "memory.wikilink.loading": "加载中…",
+        "memory.wikilink.unresolved": "目标记忆不存在"
       },
       en: {
         "memory.panel.empty": "No memories yet",
@@ -229,7 +234,12 @@ window.__ModuleLoader__.load({
         "memory.settings.apiTokenHint": "When set, write operations and secret endpoints (profile/rules/commands/vector config) require Authorization: Bearer <token>. Read-only panel calls stay open. Save empty to disable.",
         "memory.settings.apiTokenPlaceholder": "Empty = no auth (default)",
         "memory.settings.apiTokenSave": "Save Token",
-        "memory.settings.apiTokenSaved": "Token saved"
+        "memory.settings.apiTokenSaved": "Token saved",
+        "memory.wikilink.backlinks": "Links to this memory",
+        "memory.wikilink.forward": "This memory links to",
+        "memory.wikilink.empty": "No linked memories",
+        "memory.wikilink.loading": "Loading…",
+        "memory.wikilink.unresolved": "Target memory not found"
       }
     };
 
@@ -333,6 +343,21 @@ window.__ModuleLoader__.load({
       ".mneme-xdmeta{display:flex;flex-wrap:wrap;gap:4px 14px;margin-bottom:6px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}",
       ".mneme-xdcontent{margin-top:14px;font-size:14px;line-height:1.75;color:var(--dsw-alias-label-primary);white-space:pre-wrap;word-break:break-word}",
       ".mneme-xdactions{display:flex;gap:8px;margin-top:18px}",
+      // --- wiki-link backlinks panel (detail pane footer) ---
+      ".mneme-backlinks{margin-top:18px;padding-top:14px;border-top:1px solid var(--dsw-alias-border-l1);display:flex;flex-direction:column;gap:12px}",
+      ".mneme-bl-block{display:flex;flex-direction:column;gap:4px}",
+      ".mneme-bl-head{font-size:12px;font-weight:500;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-bl-list{display:flex;flex-wrap:wrap;gap:6px}",
+      ".mneme-bl-link{display:inline-flex;align-items:center;gap:6px;max-width:100%;border:none;background:none;color:var(--dsw-alias-state-business-primary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;padding:2px 8px;border-radius:6px;text-align:left}",
+      ".mneme-bl-link:hover{background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
+      ".mneme-bl-link.mneme-bl-link--dim{color:var(--dsw-alias-label-tertiary);cursor:default}",
+      ".mneme-bl-link.mneme-bl-link--dim:hover{background:none}",
+      ".mneme-bl-title{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+      ".mneme-bl-meta{flex:none;font-size:11px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-bl-empty{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}",
+      // --- inline [[wiki-link]] links inside the detail content ---
+      ".mneme-wikilink{display:inline;padding:0 2px;border:none;background:none;color:var(--dsw-alias-state-business-primary);cursor:pointer;font-family:inherit;font-size:inherit;line-height:inherit;text-decoration:underline;text-underline-offset:2px;border-radius:3px}",
+      ".mneme-wikilink:hover{background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 8%,transparent)}",
       // --- graph sub-view (fills the content area under the tabs) ---
       ".mneme-graph{flex:1;min-height:0;width:100%;display:flex;flex-direction:column;padding:12px 16px 16px;box-sizing:border-box}",
       ".mneme-graphbar{display:flex;gap:8px;align-items:center;flex:none;margin-bottom:10px}",
@@ -409,6 +434,92 @@ window.__ModuleLoader__.load({
       });
     }
 
+    // --- wiki-link (v0.6.1) -------------------------------------------------
+    // Splits detail content into literal text and clickable [[target]] /
+    // [[display|target]] links. Mirrors src/parser/wiki-link.js: single pipe
+    // only, empty / multi-pipe / unclosed markers stay literal text.
+    function wikilinkSegments(text, onClick) {
+      if (typeof text !== "string" || text.length === 0) return text;
+      const out = [];
+      let last = 0;
+      let key = 0;
+      const re = /\[\[([^\[\]]*)\]\]/g;
+      let m;
+      while ((m = re.exec(text)) !== null) {
+        const parts = m[1].split("|");
+        if (parts.length > 2) continue; // 多管道 → 非法，保留字面文本
+        const target = (parts.length === 2 ? parts[1] : parts[0]).trim();
+        if (!target) continue; // 空目标 → 非法
+        if (m.index > last) out.push(text.slice(last, m.index));
+        out.push(h("button", {
+          key: `w${key++}`,
+          type: "button",
+          className: "mneme-wikilink",
+          title: target,
+          onClick: () => onClick(target)
+        }, parts[0].trim() || target));
+        last = m.index + m[0].length;
+      }
+      if (last < text.length) out.push(text.slice(last));
+      return out.length ? out : text;
+    }
+
+    // Backlinks panel: the two wiki-link relation blocks under the detail pane.
+    // Backlinks = memories whose content links to this one; forward = memories
+    // this one links to (unresolved targets surface as dim, non-clickable).
+    // Mounted per-selection (the surrounding Fragment keys on selected.id), so
+    // state resets and the fetches re-run on every switch.
+    function BacklinksPanel({ memory, t, onJump }) {
+      const [back, setBack] = useState(null); // null = loading
+      const [forward, setForward] = useState(null);
+
+      useEffect(() => {
+        let cancelled = false;
+        if (!memory || !memory.id) return;
+        apiFetch(`/api/dsh-mneme/wikilinks/backlinks?id=${encodeURIComponent(memory.id)}`)
+          .then((r) => (r.ok ? r.json() : { backlinks: [] }))
+          .then((j) => { if (!cancelled) setBack(Array.isArray(j.backlinks) ? j.backlinks : []); })
+          .catch(() => { if (!cancelled) setBack([]); });
+        apiFetch(`/api/dsh-mneme/wikilinks/forward?id=${encodeURIComponent(memory.id)}`)
+          .then((r) => (r.ok ? r.json() : { links: [] }))
+          .then((j) => { if (!cancelled) setForward(Array.isArray(j.links) ? j.links : []); })
+          .catch(() => { if (!cancelled) setForward([]); });
+        return () => { cancelled = true; };
+      }, [memory && memory.id]);
+
+      if (!memory || !memory.id) return null;
+
+      const loading = back === null || forward === null;
+      const row = (link, i) => {
+        const canJump = !!link.id;
+        return h("button", {
+          key: link.id ?? `unresolved-${i}`,
+          type: "button",
+          className: canJump ? "mneme-bl-link" : "mneme-bl-link mneme-bl-link--dim",
+          title: canJump ? t("memory.card.open") : t("memory.wikilink.unresolved"),
+          disabled: !canJump,
+          onClick: () => onJump && onJump({ id: link.id })
+        },
+          h("span", { className: "mneme-bl-title" }, link.title || "—"),
+          link.type && h("span", { className: "mneme-bl-meta" }, typeLabel(t, link.type))
+        );
+      };
+      const section = (label, items) =>
+        h("div", { className: "mneme-bl-block" },
+          h("div", { className: "mneme-bl-head" }, label),
+          loading
+            ? h("div", { className: "mneme-bl-empty" }, t("memory.wikilink.loading"))
+            : items.length === 0
+              ? h("div", { className: "mneme-bl-empty" }, t("memory.wikilink.empty"))
+              : h("div", { className: "mneme-bl-list" }, items.map(row))
+        );
+
+      return h("div", { className: "mneme-backlinks" },
+        section(t("memory.wikilink.backlinks"), back || []),
+        section(t("memory.wikilink.forward"), forward || [])
+      );
+    }
+
     // --- Graph view: ego-graph of one entity, zero-dependency SVG force layout ---
     // The DSH client module table only whitelists platform modules, so a graph
     // library like vis-network cannot be required from a plugin. A hand-rolled
@@ -1083,6 +1194,17 @@ window.__ModuleLoader__.load({
         setSelectedId(target.id);
       };
 
+      // [[wiki-link]] click in the detail content: resolve the title to a
+      // memory (case-insensitive exact match) then jump to it. Unresolvable
+      // titles silently no-op — the link stays as display text.
+      const onWikilinkClick = (target) => {
+        if (!target) return;
+        apiFetch(`/api/dsh-mneme/wikilinks/resolve?title=${encodeURIComponent(target)}`)
+          .then((r) => (r.ok ? r.json() : null))
+          .then((j) => { if (j?.memory?.id) jumpToMemory(j.memory); })
+          .catch(() => {});
+      };
+
       const openGraphFor = (name) => {
         setGraphFocus(name || "");
         setView("graph");
@@ -1174,11 +1296,14 @@ window.__ModuleLoader__.load({
                       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-xdcontent" }, selected.content),
+                      h("div", { className: "mneme-xdcontent" },
+                        selected.content ? wikilinkSegments(selected.content, onWikilinkClick) : selected.content
+                      ),
                       h("div", { className: "mneme-xdactions" },
                         h("button", { className: "mneme-footbtn", onClick: copyContent },
                           copied ? t("memory.explorer.copied") : t("memory.explorer.copy"))
-                      )
+                      ),
+                      h(BacklinksPanel, { memory: selected, t, onJump: jumpToMemory })
                     )
                   )
                 : h("div", { className: "mneme-xempty" }, t("memory.explorer.emptyDetail"))

package/lib/config.js

@@ -4,6 +4,11 @@ export const Config = z.object({
   memoryDir: z.string().default("~/.dsh/memory"),
   autoInject: z.boolean().default(true),
   autoSummarize: z.boolean().default(true),
+  // Session lifecycle (v0.6.0): when enabled, deleting/disposing a session also
+  // archives every memory that was born in it (treating the session as a save
+  // point — entries stay recoverable via memory_archive/restoreBySession).
+  // Default OFF: legacy behavior, a disposed session leaves its memories active.
+  sessionLifecycleEnabled: z.boolean().default(false),
   // Optional model override for summarization. When both are non-empty, they
   // take priority over the session's current model. Empty = use the session's
   // active provider/model (same as before).
@@ -161,6 +166,15 @@ export const Config = z.object({
   // Prefix/semantic search over entity names (used by recall).
   entitySearchEnabled: z.boolean().default(true),
 
+  // --- wiki-link: explicit cross-memory [[links]] (v0.6.1) ----------------
+  // Opt-in, off by default. When enabled, saveWithDedupe/update fire-and-forget
+  // a wiki-link resolution pass: [[target]] / [[显示|target]] markers in a
+  // memory's content become links_to relations in entity_relations (idempotent,
+  // deduped by the unique relation index). The storage layer + read APIs
+  // (getBacklinks/getForwardLinks/resolveWikiLink) are always available
+  // regardless of this flag.
+  wikiLinkEnabled: z.boolean().default(false),
+
   // --- 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/sleep.js

@@ -108,7 +108,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   }
   const strictness = config.sleepConflictStrictness ?? "normal";
   const threshold = CONFLICT_THRESHOLDS[strictness] ?? CONFLICT_THRESHOLDS.normal;
-  const memories = service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary");
+  const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && !m.forgotten && m.type !== "summary");
   if (memories.length < 2) return { status: "skipped", reason: "too few memories" };
   if (signal?.aborted) return { status: "aborted", reason: "user activity" };
 
@@ -239,7 +239,7 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   const archived = [];
   for (const m of service.all()) {
     if (signal?.aborted) break;
-    if (m.archived || m.forgotten) continue;
+    if (m.archived || m.forgotten || m.session_disposed_at) continue;
     const ref = m.last_accessed_at ?? m.updated_at ?? m.created_at;
     if (!ref) continue;
     const t = new Date(ref).getTime();
@@ -273,7 +273,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   const limit = config.sleepPatternMinMemories ?? 100;
   const memories = service
     .list({ limit: 200, includeForgotten: false })
-    .filter((m) => !m.archived && m.type !== "summary" && m.type !== "pattern")
+    .filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary" && m.type !== "pattern")
     .sort((a, b) => (a.updated_at < b.updated_at ? 1 : -1))
     .slice(0, limit);
   if (memories.length === 0) return { status: "skipped", reason: "no memories to scan" };
@@ -342,7 +342,7 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   if (entities.length < 2) return { status: "skipped", reason: "too few entities" };
   const orphans = entities.filter((e) => (service.getRelations(e.id) ?? []).length === 0);
   if (orphans.length === 0) return { status: "skipped", reason: "no orphan entities" };
-  const memories = service.all().filter((m) => !m.archived && !m.forgotten);
+  const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && !m.forgotten);
   const seen = new Set();
   const related = [];
   const MAX_RELATIONS_PER_ORPHAN = 3;

package/lib/dream.js

@@ -495,7 +495,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   let inFlight = null;
 
   function shouldTrigger(service) {
-    const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
+    const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary");
     const count = memories.length;
     const chars = totalChars(memories);
     const overBase = count >= baseline.count + thresholdCount || chars >= baseline.chars + thresholdChars;
@@ -844,7 +844,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           : {}),
         messages: [
           { role: "system", content: [{ type: "text", text: SUMMARY_PROMPT }] },
-          { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
+          { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
         ]
       }, reportUsage));
     } catch (error) {

package/lib/index.js

@@ -317,6 +317,26 @@ export const apply = (ctx, config) => {
   const summarizer = createSummarizer(ctx, service, cfg);
   disposers.push(summarizer.dispose);
 
+  // Session lifecycle (v0.6.0): when a session leaves the store and the toggle
+  // is enabled, mark every memory born in it as session-disposed (hidden from
+  // injection/search/dream but never destroyed — recoverable via
+  // restoreBySession). Default off, so a disposed session leaves its memories
+  // active (legacy behavior). Every path is guarded: a failure inside the
+  // callback must never propagate into DSH's session teardown (that would crash
+  // the plugin on the very delete action it serves).
+  if (cfg.sessionLifecycleEnabled) {
+    disposers.push(ctx.on("session/disposed", (session) => {
+      const sessionId = session?.id;
+      if (!sessionId) return;
+      try {
+        const { disposed } = service.disposeBySession(sessionId);
+        ctx.logger?.info?.(`[dsh-mneme] session disposed, hid ${disposed} memory(s) for ${sessionId}`);
+      } catch (error) {
+        ctx.logger?.warn?.(`[dsh-mneme] session dispose failed for ${sessionId}: ${String(error)}`);
+      }
+    }));
+  }
+
   if (ctx.webServer) {
     const api = createApi(ctx, service, settings, commands ?? {
       add: () => { throw new Error("commands unavailable"); },

package/lib/parser/wiki-link.js

@@ -0,0 +1,38 @@
+/**
+ * Wiki-Link parser (v0.6.1). Given a memory's content, extract explicit
+ * cross-memory links of the form [[target]] or [[显示|target]]:
+ *   [[target]]      → { display: "target", target: "target" }
+ *   [[显示|target]] → { display: "显示",  target: "target" }
+ *
+ * Unclosed / empty-target / multi-pipe / bracket-nested markers are treated as
+ * illegal and ignored. Pure module: no store, no side effects — resolution is a
+ * separate step (resolveWikiLink) that needs a store handle.
+ */
+
+/** @returns {{display: string, target: string}[]} in source order. */
+export function parseWikiLinks(content) {
+  if (typeof content !== "string" || content.length === 0) return [];
+  const links = [];
+  // [^\[\]]* keeps a single match from crossing `]]`; an unclosed `[[` never
+  // matches, and `[[a [[b]] c]]` only yields the inner `[[b]]`.
+  const re = /\[\[([^\[\]]*)\]\]/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const inner = m[1];
+    const parts = inner.split("|");
+    if (parts.length > 2) continue; // 多管道 → 非法，忽略
+    const rawTarget = (parts.length === 2 ? parts[1] : parts[0]).trim();
+    if (!rawTarget) continue; // 空目标 → 非法，忽略
+    const rawDisplay = parts[0].trim();
+    links.push({ display: rawDisplay || rawTarget, target: rawTarget });
+  }
+  return links;
+}
+
+/** Resolve a wiki-link target title to a memory row via a case-insensitive
+ *  exact title match (store.findByTitle). Returns undefined when absent or the
+ *  store exposes no such lookup. */
+export function resolveWikiLink(store, title) {
+  if (!store || typeof title !== "string" || !title.trim()) return undefined;
+  return store.findByTitle?.(title.trim());
+}