@modusensus/dsh-mneme 0.2.3 → 0.2.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 6 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",
@@ -17,6 +17,8 @@
   "files": [
     "lib",
     "src",
+    "scripts",
+    "test",
     "cordis.patch.yml"
   ],
   "dsh": {

package/scripts/benchmark-embed.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// scripts/benchmark-embed.js
+// 嵌入吞吐量基准：测量 LocalEmbedder(ONNX) / OllamaEmbedder / OpenAIEmbedder
+// 的延迟与吞吐。src/local-embedder.js 可能尚在开发，这里用 await import() 动态
+// 加载，失败时打印友好错误而非崩溃。
+//
+// 用法：
+//   node scripts/benchmark-embed.js                                   # 默认 local
+//   node scripts/benchmark-embed.js --provider local --device cpu
+//   node scripts/benchmark-embed.js --provider ollama --model bge-m3
+//   node scripts/benchmark-embed.js --provider openai --base-url https://api.openai.com/v1 \
+//       --api-key sk-... --model text-embedding-3-small
+//   node scripts/benchmark-embed.js --texts 32 --batch-size 8 --warmup 2 --iters 5
+//   node scripts/benchmark-embed.js --help
+//
+// 环境变量（npm scripts 里可直接用）：EMBED_PROVIDER / EMBED_MODEL /
+// EMBED_DIMENSION / EMBED_DEVICE / EMBED_BATCH_SIZE / EMBED_BASE_URL /
+// EMBED_API_KEY / EMBED_CACHE_DIR。命令行参数优先于环境变量。
+
+const SAMPLE_TEXTS = [
+  "用户偏好使用中文交流，偶尔夹杂英文术语。",
+  "项目使用 SQLite 作为主存储，Markdown 作为人工可读镜像。",
+  "考研科目：公共管理学（631）与公共政策学（864）。",
+  "autoDream 在后台自动去重、合并、归档记忆。",
+  "本地模型支持 ONNX、Ollama 与 OpenAI 兼容三种后端。",
+  "Rerank 精排可以提升语义检索的 Top-K 准确率。",
+  "记忆库越大，向量检索的优势越明显。",
+  "今天完成了语义引擎的架构设计文档。",
+];
+
+function pad(s, n) {
+  const str = String(s);
+  return str.length >= n ? str : str + " ".repeat(n - str.length);
+}
+
+function parseArgs(argv) {
+  const args = {
+    provider: null, model: null, dimension: null, device: null,
+    batchSize: null, baseUrl: null, apiKey: null, cacheDir: null,
+    texts: 16, warmup: 1, iters: 5, help: false
+  };
+  const take = (key, i) => (argv[i + 1] !== undefined ? argv[i + 1] : null);
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") { args.help = true; break; }
+    if (a === "--provider") args.provider = take("provider", i++);
+    else if (a === "--model") args.model = take("model", i++);
+    else if (a === "--dimension") args.dimension = Number(take("dimension", i++)) || null;
+    else if (a === "--device") args.device = take("device", i++);
+    else if (a === "--batch-size") args.batchSize = Number(take("batch-size", i++)) || null;
+    else if (a === "--base-url") args.baseUrl = take("base-url", i++);
+    else if (a === "--api-key") args.apiKey = take("api-key", i++);
+    else if (a === "--cache-dir") args.cacheDir = take("cache-dir", i++);
+    else if (a === "--texts") args.texts = Number(take("texts", i++)) || args.texts;
+    else if (a === "--warmup") args.warmup = Number(take("warmup", i++)) || 0;
+    else if (a === "--iters") args.iters = Number(take("iters", i++)) || 1;
+    else { console.error(`未知参数：${a}（用 --help 查看用法）`); process.exit(2); }
+  }
+  // 环境变量兜底（命令行优先）
+  const env = process.env;
+  args.provider = args.provider ?? env.EMBED_PROVIDER ?? "local";
+  args.model = args.model ?? env.EMBED_MODEL ?? null;
+  args.dimension = args.dimension ?? (env.EMBED_DIMENSION ? Number(env.EMBED_DIMENSION) : null);
+  args.device = args.device ?? env.EMBED_DEVICE ?? "cpu";
+  args.batchSize = args.batchSize ?? (env.EMBED_BATCH_SIZE ? Number(env.EMBED_BATCH_SIZE) : 8);
+  args.baseUrl = args.baseUrl ?? env.EMBED_BASE_URL ?? "";
+  args.apiKey = args.apiKey ?? env.EMBED_API_KEY ?? "";
+  args.cacheDir = args.cacheDir ?? env.EMBED_CACHE_DIR ?? "";
+  return args;
+}
+
+function usage() {
+  console.log(`嵌入吞吐量基准（dsh-mneme）
+
+用法：
+  node scripts/benchmark-embed.js [选项]
+
+选项：
+  --provider <local|ollama|openai>   嵌入后端（默认 local，可由环境变量 EMBED_PROVIDER 覆盖）
+  --model <name>                     模型名（local=HF 模型 id；ollama=Ollama 模型名；openai=API 模型名）
+  --dimension <n>                    向量维度（不填则按后端推断）
+  --device <cpu|wasm|gpu>            ONNX 设备（仅 local 生效，默认 cpu）
+  --batch-size <n>                   分批嵌入条数（默认 8）
+  --base-url <url>                   openai/ollama 端点（ollama 默认 http://localhost:11434）
+  --api-key <key>                    openai 密钥
+  --cache-dir <dir>                  local 模型缓存目录
+  --texts <n>                        生成样本文本条数（默认 16，从示例库循环）
+  --warmup <n>                       预热轮数（默认 1）
+  --iters <n>                        计时轮数（默认 5）
+  -h, --help                         显示帮助并退出
+
+环境变量：EMBED_PROVIDER / EMBED_MODEL / EMBED_DIMENSION / EMBED_DEVICE /
+  EMBED_BATCH_SIZE / EMBED_BASE_URL / EMBED_API_KEY / EMBED_CACHE_DIR
+  （命令行参数优先）
+`);
+}
+
+function buildTexts(n) {
+  const out = [];
+  for (let i = 0; i < n; i++) out.push(SAMPLE_TEXTS[i % SAMPLE_TEXTS.length]);
+  return out;
+}
+
+/** 安全读取维度：规避部分版本 getter 自递归的坑，取不到则回退 _dimension。 */
+function safeDimension(embedder, fallback) {
+  try {
+    const d = embedder?.dimension;
+    return d > 0 ? d : fallback;
+  } catch {
+    return embedder?._dimension ?? fallback;
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) { usage(); process.exit(0); }
+
+  let mod;
+  try {
+    mod = await import("../src/local-embedder.js");
+  } catch (err) {
+    console.error("无法加载 src/local-embedder.js：");
+    console.error(`  ${err.message}`);
+    console.error("该模块可能尚未创建。基准脚本依赖 createEmbedderByProvider（local/ollama/openai）。");
+    process.exit(1);
+  }
+  const { createEmbedderByProvider } = mod;
+  if (typeof createEmbedderByProvider !== "function") {
+    console.error("src/local-embedder.js 未导出 createEmbedderByProvider，请先实现该模块。");
+    process.exit(1);
+  }
+
+  // 构造后端
+  let embedder;
+  try {
+    embedder = createEmbedderByProvider(args.provider, {
+      model: args.model ?? undefined,
+      dimension: args.dimension ?? undefined,
+      device: args.device,
+      batchSize: args.batchSize,
+      baseUrl: args.baseUrl || undefined,
+      apiKey: args.apiKey || undefined,
+      cacheDir: args.cacheDir || undefined,
+      logger: null
+    });
+    await embedder.init();
+  } catch (err) {
+    console.error(`初始化 ${args.provider} 后端失败：${err.message}`);
+    console.error("请检查模型是否已下载 / Ollama 是否运行 / API 配置是否正确。");
+    process.exit(1);
+  }
+
+  const texts = buildTexts(args.texts);
+  const dim = safeDimension(embedder, args.dimension ?? 0);
+  console.log("══════ dsh-mneme 嵌入基准 ══════");
+  console.log(`后端：${args.provider}  模型：${embedder.model ?? "（默认）"}  维度：${dim || "未知"}  设备：${args.device}`);
+  console.log(`文本：${texts.length} 条  批次：${args.batchSize}  预热：${args.warmup}  计时：${args.iters}\n`);
+
+  // 预热（含首次推理/缓存填充）
+  for (let i = 0; i < args.warmup; i++) {
+    try { await embedder.embed(texts); } catch (err) { console.error(`预热失败：${err.message}`); process.exit(1); }
+  }
+
+  // 计时
+  const rows = [];
+  for (let i = 0; i < args.iters; i++) {
+    const t0 = process.hrtime.bigint();
+    try {
+      const vecs = await embedder.embed(texts);
+      if (!Array.isArray(vecs) || vecs.length !== texts.length) {
+        console.error(`第 ${i + 1} 轮返回 ${Array.isArray(vecs) ? vecs.length : "?"} 条向量，期望 ${texts.length}。`);
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error(`第 ${i + 1} 轮嵌入失败：${err.message}`);
+      process.exit(1);
+    }
+    const ms = Number(process.hrtime.bigint() - t0) / 1e6;
+    rows.push({ iter: i + 1, ms, perText: ms / texts.length, tps: (texts.length * 1000) / ms });
+  }
+
+  // 结果表
+  console.log(`${pad("轮次", 6)}${pad("文本数", 8)}${pad("耗时(ms)", 12)}${pad("ms/条", 10)}${pad("条/秒", 12)}`);
+  for (const r of rows) {
+    console.log(`${pad(r.iter, 6)}${pad(texts.length, 8)}${pad(r.ms.toFixed(1), 12)}${pad(r.perText.toFixed(3), 10)}${pad(r.tps.toFixed(1), 12)}`);
+  }
+  const msArr = rows.map((r) => r.ms);
+  const avg = msArr.reduce((a, b) => a + b, 0) / msArr.length;
+  const min = Math.min(...msArr);
+  const max = Math.max(...msArr);
+  console.log("\n汇总（均值 / 最小 / 最大）：");
+  console.log(`  耗时 ms：${avg.toFixed(1)} / ${min.toFixed(1)} / ${max.toFixed(1)}`);
+  console.log(`  吞吐：${(texts.length * 1000 / avg).toFixed(1)} 条/秒（平均每轮 ${texts.length} 条）`);
+  console.log("══════ 结束 ══════");
+  embedder.dispose?.();
+}
+
+main().catch((err) => {
+  console.error(`未预期错误：${err?.stack ?? err}`);
+  process.exit(1);
+});

package/scripts/benchmark-rerank.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+// scripts/benchmark-rerank.js
+// Rerank 延迟基准：测量 LocalReranker（Xenova/bge-reranker-base，交叉编码）
+// 在不同候选集规模下的精排延迟。src/reranker.js 尚在开发（Phase 2），这里用
+// await import() 动态加载，失败时打印友好错误而非崩溃。
+//
+// 用法：
+//   node scripts/benchmark-rerank.js                                  # 默认候选 [10,50,100,500]
+//   node scripts/benchmark-rerank.js --candidates 10,100,1000
+//   node scripts/benchmark-rerank.js --candidates 10 --top-k 3 --model Xenova/bge-reranker-base
+//   node scripts/benchmark-rerank.js --device cpu --batch-size 4
+//   node scripts/benchmark-rerank.js --help
+//
+// 环境变量：RERANK_MODEL / RERANK_DEVICE / RERANK_BATCH_SIZE / RERANK_CACHE_DIR。
+
+function pad(s, n) {
+  const str = String(s);
+  return str.length >= n ? str : str + " ".repeat(n - str.length);
+}
+
+const QUERY = "如何为记忆插件配置本地语义搜索模型？";
+
+// 与 benchmark-embed.js 同源的样本文本库，模拟记忆库候选。
+const CANDIDATE_TEXTS = [
+  "用户偏好使用中文交流，偶尔夹杂英文术语。",
+  "项目使用 SQLite 作为主存储，Markdown 作为人工可读镜像。",
+  "考研科目：公共管理学（631）与公共政策学（864）。",
+  "autoDream 在后台自动去重、合并、归档记忆。",
+  "本地模型支持 ONNX、Ollama 与 OpenAI 兼容三种后端。",
+  "Rerank 精排可以提升语义检索的 Top-K 准确率。",
+  "记忆库越大，向量检索的优势越明显。",
+  "今天完成了语义引擎的架构设计文档。",
+  "Web 记忆面板支持按类型浏览与全文搜索。",
+  "用户每天 9-18 点在线上班，上午做深度工作。",
+];
+
+function parseArgs(argv) {
+  const args = {
+    candidates: [10, 50, 100, 500], topK: 5, model: null, device: null,
+    batchSize: null, cacheDir: null, query: QUERY, help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const take = (n) => (argv[i + 1] !== undefined ? argv[i + 1] : null);
+    if (a === "--help" || a === "-h") { args.help = true; break; }
+    if (a === "--candidates") {
+      args.candidates = String(take("candidates", i++)).split(",").map(Number).filter((n) => n > 0);
+      if (!args.candidates.length) args.candidates = [10];
+    } else if (a === "--top-k") args.topK = Number(take("top-k", i++)) || args.topK;
+    else if (a === "--model") args.model = take("model", i++);
+    else if (a === "--device") args.device = take("device", i++);
+    else if (a === "--batch-size") args.batchSize = Number(take("batch-size", i++)) || null;
+    else if (a === "--cache-dir") args.cacheDir = take("cache-dir", i++);
+    else if (a === "--query") args.query = take("query", i++);
+    else { console.error(`未知参数：${a}（用 --help 查看用法）`); process.exit(2); }
+  }
+  const env = process.env;
+  args.model = args.model ?? env.RERANK_MODEL ?? null;
+  args.device = args.device ?? env.RERANK_DEVICE ?? "cpu";
+  args.batchSize = args.batchSize ?? (env.RERANK_BATCH_SIZE ? Number(env.RERANK_BATCH_SIZE) : 8);
+  args.cacheDir = args.cacheDir ?? env.RERANK_CACHE_DIR ?? "";
+  return args;
+}
+
+function usage() {
+  console.log(`Rerank 延迟基准（dsh-mneme）
+
+用法：
+  node scripts/benchmark-rerank.js [选项]
+
+选项：
+  --candidates <n1,n2,...>   候选集规模列表，逗号分隔（默认 10,50,100,500）
+  --top-k <n>                精排返回条数（默认 5）
+  --model <name>             Rerank 模型（默认 Xenova/bge-reranker-base）
+  --device <cpu|wasm|gpu>    ONNX 设备（默认 cpu）
+  --batch-size <n>           批大小（默认 8）
+  --cache-dir <dir>          模型缓存目录
+  --query <text>             检索 query（默认内置示例）
+  -h, --help                 显示帮助并退出
+
+环境变量：RERANK_MODEL / RERANK_DEVICE / RERANK_BATCH_SIZE / RERANK_CACHE_DIR
+  （命令行参数优先）
+`);
+}
+
+function buildCandidates(n) {
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const t = CANDIDATE_TEXTS[i % CANDIDATE_TEXTS.length];
+    out.push(i < CANDIDATE_TEXTS.length ? t : `${t} —— 变体 #${i + 1}`);
+  }
+  return out;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) { usage(); process.exit(0); }
+
+  let mod;
+  try {
+    mod = await import("../src/reranker.js");
+  } catch (err) {
+    console.error("无法加载 src/reranker.js：");
+    console.error(`  ${err.message}`);
+    console.error("该模块属 Phase 2，可能尚未创建。基准脚本依赖导出 LocalReranker。");
+    process.exit(1);
+  }
+  const { LocalReranker } = mod;
+  if (typeof LocalReranker !== "function") {
+    console.error("src/reranker.js 未导出 LocalReranker，请先实现该模块。");
+    process.exit(1);
+  }
+
+  let reranker;
+  try {
+    reranker = new LocalReranker({
+      model: args.model ?? undefined,
+      device: args.device,
+      batchSize: args.batchSize,
+      cacheDir: args.cacheDir || undefined,
+      logger: null
+    });
+    await reranker.init();
+  } catch (err) {
+    console.error(`初始化 Reranker 失败：${err.message}`);
+    console.error("请检查模型是否已下载、设备配置是否正确。");
+    process.exit(1);
+  }
+
+  console.log("══════ dsh-mneme Rerank 延迟基准 ══════");
+  console.log(`模型：${reranker.model ?? "（默认）"}  设备：${args.device}  候选规模：${args.candidates.join(", ")}  Top-K：${args.topK}`);
+  console.log(`query：${args.query}\n`);
+
+  // 小规模预热（含首次加载推理）
+  try {
+    await reranker.rerank(args.query, buildCandidates(5), 3);
+  } catch (err) {
+    console.error(`预热失败：${err.message}`);
+    process.exit(1);
+  }
+
+  console.log(`${pad("候选数", 10)}${pad("Top-K", 8)}${pad("耗时(ms)", 12)}${pad("ms/候选", 10)}`);
+  for (const n of args.candidates) {
+    const candidates = buildCandidates(n);
+    const t0 = process.hrtime.bigint();
+    try {
+      const result = await reranker.rerank(args.query, candidates, args.topK);
+      if (!Array.isArray(result)) {
+        console.error(`候选 ${n} 时 rerank 返回非数组，请检查 LocalReranker.rerank 的返回约定。`);
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error(`候选 ${n} 时 rerank 失败：${err.message}`);
+      process.exit(1);
+    }
+    const ms = Number(process.hrtime.bigint() - t0) / 1e6;
+    console.log(`${pad(n, 10)}${pad(args.topK, 8)}${pad(ms.toFixed(1), 12)}${pad((ms / n).toFixed(3), 10)}`);
+  }
+  console.log("══════ 结束 ══════");
+  reranker.dispose?.();
+}
+
+main().catch((err) => {
+  console.error(`未预期错误：${err?.stack ?? err}`);
+  process.exit(1);
+});

package/scripts/e2e-dsh.js

@@ -0,0 +1,216 @@
+// scripts/e2e-dsh.js
+// 端到端演示：用 cordis 搭建最小 DSH 环境，真实装载 dsh-mneme 插件，
+// 走一遍完整用户流程（工具注册 → 保存/搜索记忆 → 上下文注入 → 会话摘要 → autoDream）。
+//
+// 运行：node scripts/e2e-dsh.js
+import { Context } from "@deepseek-ai/cordis";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import * as mneme from "../lib/index.js";
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// ---------------------------------------------------------------- 环境
+const memDir = mkdtempSync(join(tmpdir(), "dsh-mneme-e2e-"));
+const ctx = new Context();
+
+// 插件声明的 5 个依赖服务（tools / systemPrompt / webServer / llm / agentDefaultModel）
+const registeredTools = [];
+const injectContexts = [];
+const apiRoutes = [];
+const registeredCommands = new Map();
+let llmCalls = [];
+
+ctx.provide("tools", {
+  register(def) { registeredTools.push(def); return () => {}; }
+});
+ctx.provide("commands", {
+  register(def) { registeredCommands.set(def.name, def); return () => registeredCommands.delete(def.name); }
+});
+ctx.provide("systemPrompt", {
+  context(def) { injectContexts.push(def); return () => {}; }
+});
+ctx.provide("webServer", {
+  register(route) { apiRoutes.push(route); return () => {}; }
+});
+ctx.provide("agentDefaultModel", {
+  currentSelection() { return { provider: "mock", model: "mock-model" }; }
+});
+
+// LLM mock：按 purpose / 消息内容返回合理结果（模拟真实 LLM 的巩固行为）
+ctx.provide("llm", {
+  async *stream(options) {
+    llmCalls.push(options.purpose);
+    const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+    let text = "";
+    if (options.purpose === "summarization") {
+      text = JSON.stringify([
+        { type: "preference", title: "语言偏好", content: "用户偏好使用中文交流", importance: 4 }
+      ]);
+    } else if (options.purpose === "compaction" && userText.includes("id=")) {
+      // 从传入的记忆清单解析 id 与类型，动态构造有效决策：优先演示 merge，其余 keep
+      const entries = [...userText.matchAll(/id=([^\s|]+).*?type=(\w+)/g)].map((m) => ({ id: m[1], type: m[2] }));
+      const byType = {};
+      for (const e of entries) (byType[e.type] ??= []).push(e.id);
+      const decisions = [];
+      const claimed = new Set();
+      const mergeType = Object.keys(byType).find((t) => byType[t].length >= 2);
+      if (mergeType) {
+        const ids = byType[mergeType];
+        decisions.push({
+          action: "merge", ids, keepSource: ids[0],
+          title: "合并条目", content: "两条主题相近的记忆合并后的精炼摘要", importance: 4
+        });
+        ids.forEach((id) => claimed.add(id));
+      }
+      for (const e of entries) {
+        if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
+      }
+      text = JSON.stringify(decisions);
+    } else if (options.purpose === "compaction") {
+      text = "记忆库总览：用户偏好中文交流；工作偏好（上午深度工作）；项目采用 SQLite 存储。";
+    }
+    yield { type: "block-start", index: 0, blockType: "text" };
+    yield { type: "text-delta", index: 0, text };
+    yield { type: "block-end", index: 0, block: { type: "text" } };
+    yield { type: "finish", reason: { kind: "stop" } };
+  }
+});
+
+// ---------------------------------------------------------------- 装载
+const fiber = ctx.plugin(
+  { name: mneme.name, inject: mneme.inject, Config: mneme.Config, apply: mneme.apply },
+  {
+    memoryDir: memDir,
+    autoInject: true,
+    autoSummarize: true,
+    maxInjectedItems: 5,
+    importanceThreshold: 3,
+    autoDream: true,
+    dreamThresholdCount: 3,
+    dreamThresholdChars: 100,
+    dreamDelayMs: 80
+  }
+);
+await fiber;
+
+// ---------------------------------------------------------------- 工具
+const tool = (name) => registeredTools.find((t) => t.name === name);
+
+console.log("══════ dsh-mneme 端到端演示 ══════");
+console.log(`记忆目录：${memDir}\n`);
+
+// 1. 装载检查
+console.log("【1】插件装载");
+const checks = [];
+checks.push(["注册 6 个模型工具", registeredTools.length === 6]);
+checks.push(["注册 2 个注入上下文", injectContexts.length === 2 && injectContexts[0].name === "memory"]);
+checks.push(["注册 9 条 API 路由", apiRoutes.length === 9]);
+for (const [label, ok] of checks) console.log(`  ${ok ? "✅" : "❌"} ${label}`);
+if (!checks.every(([, ok]) => ok)) { console.log("\n装载检查失败，中止。"); process.exit(1); }
+console.log(`  工具：${registeredTools.map((t) => t.name).join(", ")}\n`);
+
+// 2. 保存记忆（工具执行）
+console.log("【2】memory_save 保存记忆");
+const saves = [];
+saves.push(await tool("memory_save").execute({ type: "preference", title: "语言", content: "用户用中文交流", importance: 5 }));
+saves.push(await tool("memory_save").execute({ type: "preference", title: "工作时段", content: "9-18 点在线，上午深度工作", importance: 4 }));
+saves.push(await tool("memory_save").execute({ type: "preference", title: "工作习惯", content: "习惯上午处理复杂任务", importance: 3 }));
+saves.push(await tool("memory_save").execute({ type: "project", title: "记忆插件", content: "dsh-mneme 用 SQLite + Markdown 镜像", importance: 4 }));
+saves.push(await tool("memory_save").execute({ type: "decision", title: "存储选型", content: "确定使用 node:sqlite", importance: 5 }));
+// 同标题再存一次 → 应触发去重合并
+saves.push(await tool("memory_save").execute({ type: "preference", title: "语言", content: "用户用中文交流，偶尔英文", importance: 5 }));
+for (const s of saves) console.log(`  memory ${s.action}: ${s.id}`);
+console.log("  同标题二次保存 → 触发 merge ✓\n");
+
+// 3. 搜索
+console.log("【3】memory_search / memory_list");
+const search = await tool("memory_search").execute({ query: "SQLite" });
+console.log(`  搜索 "SQLite" → ${search.items.length} 条`);
+const list = await tool("memory_list").execute({ type: "preference" });
+console.log(`  preference 共 ${list.total} 条\n`);
+
+// 4. 上下文注入
+console.log("【4】自动注入（新会话上下文）");
+const injected = injectContexts[0].text({});
+console.log(injected ? `  ${injected.split("\n").filter(Boolean).map((l) => "  " + l).join("\n")}` : "  （空）");
+console.log("");
+
+// 5. 会话摘要（turn/end 事件）
+console.log("【5】会话摘要（模拟 turn/end）");
+const session = {
+  id: "e2e-session-1",
+  events: [
+    { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "我偏好中文交流，以后都用中文。" }] } }
+  ],
+  requestHeader() { return { config: { provider: "mock", model: "mock-model" } }; }
+};
+await ctx.emit("session/event", session, { type: "turn/end" });
+await sleep(50);
+const afterSummary = await tool("memory_search").execute({ query: "中文交流" });
+console.log(`  摘要入库：${afterSummary.items.length} 条命中（source: session）\n`);
+
+// 6. autoDream
+console.log("【6】autoDream（阈值触发 → LLM 决策 → merge + 摘要）");
+console.log("  等待调度器触发（delay 80ms）…");
+await sleep(400);
+const injectedAfter = injectContexts[0].text({});
+const hasSummary = injectedAfter.includes("记忆库总览");
+console.log(`  注入中出现"记忆库总览"：${hasSummary ? "是 ✅" : "否 ❌"}`);
+const prefs = await tool("memory_list").execute({ type: "preference" });
+console.log(`  dream merge 后 preference 条目：${prefs.items.length}（dream 时 4 条相近项，merge 成 1 条）`);
+
+// 7. Web API 模拟调用
+console.log("\n【7】Web 面板 API（/api/dsh-mneme/list）");
+const listRoute = apiRoutes.find((r) => r.path === "/api/dsh-mneme/list");
+const res = { writeHead(code, h) { this.statusCode = code; this.headers = h; return this; }, end(body) { this.body = body; } };
+await listRoute.handler({ url: "/api/dsh-mneme/list?type=project" }, res);
+const payload = JSON.parse(res.body);
+console.log(`  HTTP ${res.statusCode}，project 条目 ${payload.items.length} 条\n`);
+
+// 8. 用户画像 / 规则 / 自定义命令
+console.log("【8】用户画像 / 规则 / 自定义命令");
+function apiReq(path, method = "GET", body = null) {
+  const listeners = {};
+  const r = {
+    url: path, method, headers: {},
+    on(ev, fn) { listeners[ev] = fn; return r; },
+    emit(ev, data) { listeners[ev]?.(data); return r; }
+  };
+  if (body !== null) {
+    process.nextTick(() => { r.emit("data", Buffer.from(JSON.stringify(body))); r.emit("end"); });
+  }
+  return r;
+}
+function apiRes() { return { statusCode: 0, body: "", writeHead(code) { this.statusCode = code; return this; }, end(body) { this.body = body; } }; }
+
+const profileRoute = apiRoutes.find((r) => r.path === "/api/dsh-mneme/profile");
+const rp = apiRes();
+await profileRoute.handler(apiReq("/api/dsh-mneme/profile", "PUT", { profile: "我是后端开发者，擅长 Node.js" }), rp);
+const rulesRoute = apiRoutes.find((r) => r.path === "/api/dsh-mneme/rules");
+const rr = apiRes();
+await rulesRoute.handler(apiReq("/api/dsh-mneme/rules", "PUT", { rules: ["回答时先给结论", "使用简体中文"] }), rr);
+const userSettings = injectContexts.find((c) => c.name === "user-settings").text({});
+console.log(`  注入含用户画像：${userSettings.includes("后端开发者") ? "✅" : "❌"}`);
+console.log(`  注入含规则：${userSettings.includes("先给结论") ? "✅" : "❌"}`);
+const cmdRoute = apiRoutes.find((r) => r.path === "/api/dsh-mneme/commands");
+const rc = apiRes();
+await cmdRoute.handler(apiReq("/api/dsh-mneme/commands", "POST", { name: "review", description: "审查代码", instruction: "请按项目规范审查当前代码" }), rc);
+const cmdRegistered = registeredCommands.has("review");
+console.log(`  自定义命令 /review 已注册：${cmdRegistered ? "✅" : "❌"}`);
+if (cmdRegistered) {
+  const handler = registeredCommands.get("review").handler;
+  const result = await handler({ agent: {}, rawInput: "", signal: null });
+  console.log(`  命令触发返回：${result.text.slice(0, 24)}…`);
+}
+console.log("");
+
+// ---------------------------------------------------------------- 汇总
+console.log("══════ 汇总 ══════");
+console.log(`  LLM 调用：${llmCalls.join(" → ")}`);
+console.log(`  记忆文件：${memDir}`);
+const all = await tool("memory_list").execute({});
+console.log(`  当前可注入条目：${all.total}`);
+console.log("══════ 演示结束 ══════");
+fiber.dispose?.();