dsh-memory-engine 0.0.0-stage → 0.5.1

package/lib/index.js

@@ -0,0 +1,179 @@
+import { MemoryStore } from './store.js';
+import { chars, titleOf } from './decay.js';
+import { generateMap, mapReport, openMap } from './map.js';
+import { startMapServer } from './serve.js';
+
+export const name = 'memory-engine';
+export const inject = ['tools'];
+
+function report(ctx, error) {
+  try {
+    const logger = typeof ctx?.logger === 'function' ? ctx.logger(name) : ctx?.logger;
+    logger?.error?.(`memory-engine: ${error?.message ?? String(error)}`);
+  } catch { /* Error reporting must not take down the host. */ }
+}
+
+function warn(ctx, message) {
+  try {
+    const logger = typeof ctx?.logger === 'function' ? ctx.logger(name) : ctx?.logger;
+    if (logger?.warn) logger.warn(message);
+    else console.warn(`[dsh-memory-engine] ${message}`);
+  } catch { /* Preview failures must not affect the memory tools. */ }
+}
+
+export function createTools(defineTool, store = new MemoryStore(), { map = generateMap, warning = message => warn(null, message) } = {}) {
+  const output = { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: value }] };
+  return [
+    defineTool({
+      name: 'memory_save',
+      description: '把值得记住的事保存到跨会话的本地记忆。与 QQ 桥接记忆独立。重复正文自动合并。',
+      parameters: {
+        text: { type: 'string', required: true, description: '记忆正文，最多 2000 字' },
+        kind: { type: 'string', description: '分类，默认对话；可用知识/印象/日记/对话/事件或自定义' },
+        heat: { type: 'number', description: '1=热，2=温，3=冷；省略按情绪推断' },
+        who: { type: 'string', description: '跟谁有关' },
+        ts: { type: 'number', description: '事情发生的毫秒时间戳，默认现在' },
+      }, output,
+      async execute(args) {
+        const memory = store.save(args);
+        if (memory.merged) return `已合并到既有记忆（第 ${memory.merged.index} 条，相似度 ${memory.merged.similarity.toFixed(2)}）：${chars(memory.text, 40)}`;
+        return `已记住：${chars(memory.text, 40)}（重要度 ${['', '热', '温', '冷'][memory.heat]}）`;
+      },
+    }),
+    defineTool({
+      name: 'memory_recall',
+      description: '按话题查跨会话的本地记忆，并联想相关条目。q 使用具体关键词，如「古茗」「光遇 蜡烛」。与 QQ 桥接记忆独立。',
+      parameters: {
+        q: { type: 'string', required: true, description: '要查的话题或关键词' },
+        limit: { type: 'number', description: '默认 8，最大 20' },
+        hops: { type: 'number', description: '联想跳数，默认 1；0 只查直接命中，最大 2' },
+        kind: { type: 'string', description: '只看某一分类' },
+      }, output,
+      async execute(args) {
+        const hits = store.recall(args);
+        if (!hits.length) return `没有找到跟「${args.q}」相关的记忆。`;
+        let index = 0;
+        return ['direct', 'spread'].map(via => {
+          const group = hits.filter(hit => hit.via === via);
+          if (!group.length) return '';
+          return [via === 'direct' ? '【直接命中】' : '【联想到的】', ...group.map(hit =>
+            `${++index}. [${hit.kind}] ${titleOf(hit)}（留存 ${hit.retention.toFixed(2)}；id=${hit.id}）：${chars(hit.text, 120)}`)].join('\n');
+        }).filter(Boolean).join('\n\n');
+      },
+    }),
+    defineTool({
+      name: 'memory_forget',
+      description: '删除本地记忆。id/q/older_than_days 三选一。q 批量删除先报告数量，用户确认后带 confirm=true 再调用。',
+      parameters: {
+        id: { type: 'string', description: '精确删除的记忆 id' },
+        q: { type: 'string', description: '按关键词批量删除，必须二次确认' },
+        older_than_days: { type: 'number', description: '仅删除超过此天数且留存低于 0.15 的条目' },
+        confirm: { type: 'boolean', description: '收到用户对本次关键词批删的确认后才设为 true' },
+      }, output,
+      async execute(args) {
+        const result = store.forget(args);
+        return result.needsConfirmation ? `匹配到 ${result.count} 条，确认请带 confirm=true 再调一次。`
+          : `已删除 ${result.count} 条记忆。`;
+      },
+    }),
+    defineTool({
+      name: 'memory_dedupe', description: '检测全库相似重复记忆。默认只预览；用户确认后显式 dry_run=false 才备份并合并。',
+      parameters: {
+        threshold: { type: 'number', description: 'LCS 相似度阈值，默认 0.7，范围 0.5–0.95' },
+        dry_run: { type: 'boolean', description: '默认 true，只报告；false 备份后执行合并' },
+      }, output,
+      async execute(args) {
+        const result = store.dedupe(args);
+        if (!result.dryRun) return `已合并 ${result.groups.length} 组，删除 ${result.removed} 条。备份：${result.backup}（耗时 ${result.elapsedMs.toFixed(0)}ms）`;
+        const involved = result.groups.reduce((sum, group) => sum + group.texts.length, 0);
+        return [`发现 ${result.groups.length} 组重复（共 ${involved} 条 → 可合并为 ${result.groups.length} 条）`,
+          ...result.groups.map((group, index) => `组 ${index + 1}：${group.texts.length} 条 → 保留「${chars(group.memory.text, 80)}」（boosts 合计 ${group.memory.boosts}）\n`
+            + group.texts.map(text => `  - ${chars(text, 80)}`).join('\n')),
+          '确认执行请带 dry_run=false', `耗时 ${result.elapsedMs.toFixed(0)}ms`].join('\n');
+      },
+    }),
+    defineTool({
+      name: 'memory_import', description: '从 JSON、Markdown 目录、逐行纯文本或 qq-bridge 导入本地记忆。默认只预览，显式 dry_run=false 才备份并导入；不会修改来源。新增后自动生成图谱。',
+      parameters: {
+        source: { type: 'string', required: true, description: 'qq-bridge / json / markdown / text' },
+        path: { type: 'string', description: 'json/text 的本地文件绝对路径，或 markdown 的目录绝对路径；qq-bridge 无需此参数' },
+        dry_run: { type: 'boolean', description: '默认 true，只报告；false 先备份本插件记忆再导入' },
+      }, output,
+      async execute(args) {
+        const result = args.source === 'qq-bridge' ? store.importBridge(args) : await store.importFile(args);
+        if (result.missing) return '找不到桥接目录，可用 QQ_BRIDGE_DIR 环境变量指定';
+        let mapLine;
+        if (!result.dryRun && result.imported > 0) {
+          try { mapLine = `已同步生成神经网络图：${map(store).file}`; }
+          catch (error) { warning(`图谱生成失败，记忆已成功导入：${error.message}`); }
+        }
+        return [result.dryRun ? `将从 ${args.source} 导入：` : `已从 ${args.source} 导入：`,
+          ...Object.entries(result.counts).map(([kind, count]) => `- ${kind} ${count} 条（${result.dryRun ? '可新增' : '新增'} ${result.added[kind]} 条）`),
+          `合计 ${result.candidates} 条；其中 ${result.skipped} 条与现有或本批重复会被跳过。`,
+          `${result.dryRun ? '预计导入后' : '导入后'}总数：${result.total} 条（新增 ${result.imported} 条）`,
+          ...(result.dryRun ? ['确认执行请带 dry_run=false'] : [`备份：${result.backup}`]),
+          ...(result.warnings.length ? ['来源提示：', ...result.warnings] : []),
+          `耗时 ${(result.elapsedMs / 1000).toFixed(2)} 秒`, ...(mapLine ? [mapLine] : [])].join('\n');
+      },
+    }),
+    defineTool({
+      name: 'memory_map', description: '把当前本地记忆生成可离线打开的神经网络 HTML 图谱，返回文件路径、节点和关联边数量。',
+      parameters: {
+        out: { type: 'string', description: '输出 HTML 路径，默认 DSH_HOME/memory-engine/starmap.html' },
+        title: { type: 'string', description: '页面标题，默认“我的记忆神经网络”' },
+        open: { type: 'boolean', description: '默认 false；true 时用系统默认浏览器打开' },
+      }, output,
+      async execute(args) {
+        const result = map(store, args);
+        if (args.open === true) await openMap(result.file);
+        return mapReport(result);
+      },
+    }),
+    defineTool({
+      name: 'memory_stats', description: '查看本地记忆总数、分类、衰减状态、最老日期和存储路径及体积。',
+      parameters: {}, output,
+      async execute() {
+        const stats = store.stats();
+        const kinds = Object.entries(stats.kinds).map(([kind, count]) => `${kind} ${count}`).join(' / ');
+        return `记忆引擎状态\n- 总条数：${stats.total}${kinds ? `（${kinds}）` : ''}\n`
+          + `- 快忘了的（留存<0.3）：${stats.fading} 条\n`
+          + `- 最老：${stats.oldest === null ? '暂无' : `${new Date(stats.oldest).toISOString().slice(0, 10)}（${stats.ageDays} 天前）`}\n`
+          + `- 存储：${stats.file}（${(stats.bytes / 1024).toFixed(1)} KB）`;
+      },
+    }),
+  ];
+}
+
+export function apply(ctx) {
+  try {
+    if (typeof ctx?.tools?.register !== 'function') throw new Error('tools 服务不可用');
+    if (typeof ctx.effect !== 'function') throw new Error('ctx.effect 不可用');
+    const registration = ctx.effect(async () => {
+      const disposers = [];
+      try {
+        // The host resolves this public SDK; no bundled copy or runtime dependency.
+        const { defineTool } = await import('@deepseek-ai/dsh-tools');
+        const store = new MemoryStore();
+        for (const tool of createTools(defineTool, store, { warning: message => warn(ctx, message) })) disposers.push(ctx.tools.register(tool));
+        try {
+          const server = await startMapServer({ store, warn: message => warn(ctx, message) });
+          disposers.push(() => server.close());
+        } catch (error) {
+          warn(ctx, `图谱服务启动失败，记忆工具仍可用：${error.message}`);
+        }
+        const timer = setTimeout(() => {
+          try { if (store.read().length > 0) generateMap(store); }
+          catch (error) { warn(ctx, `启动时图谱生成失败：${error.message}`); }
+        }, 3000);
+        timer.unref();
+        disposers.push(() => clearTimeout(timer));
+        return () => { for (const dispose of disposers.reverse()) dispose(); };
+      } catch (error) {
+        for (const dispose of disposers.reverse()) { try { dispose(); } catch { /* keep unwinding */ } }
+        report(ctx, error);
+      }
+    }, 'memory-engine.tools');
+    // Await setup without returning its disposer as a second plugin teardown.
+    return Promise.resolve(registration).then(() => undefined, error => { report(ctx, error); });
+  } catch (error) { report(ctx, error); }
+}

package/lib/map.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+import { scoreMemories, layoutMemories, renderHtml } from './render/index.mjs';
+import { readConfig } from './config.js';
+
+export function generateMap(store, { out, title = '我的记忆神经网络' } = {}) {
+  const started = performance.now();
+  if (typeof title !== 'string' || !title.trim()) throw new Error('title 必须是非空字符串');
+  if (out !== undefined && (typeof out !== 'string' || !out.trim())) throw new Error('out 必须是 HTML 文件路径');
+  const file = path.resolve(out ?? path.join(path.dirname(store.file), 'starmap.html'));
+  if (path.extname(file).toLowerCase() !== '.html') throw new Error('输出文件必须以 .html 结尾');
+  const home = path.dirname(path.dirname(store.file));
+  const bridge = process.env.QQ_BRIDGE_DIR || readConfig(home).bridgeRoot;
+  if (bridge) {
+    const relative = path.relative(path.resolve(bridge), file);
+    if (relative === '' || (!relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative))) {
+      throw new Error('桥接目录只读，请把图谱输出到插件数据目录或其他目录');
+    }
+  }
+  const items = store.read().map(({ id, text, title: nodeTitle, ts, kind, heat }) => ({ id, text,
+    title: nodeTitle || Array.from(text).slice(0, 20).join(''), ts, kind, heat }));
+  const now = store.now();
+  const { nodes, links, review } = scoreMemories(items, now);
+  const stars = layoutMemories(nodes);
+  const kinds = Object.fromEntries([...new Set(stars.map(star => star.kind))].map(kind => [kind, stars.filter(star => star.kind === kind).length]));
+  const payload = { generatedAt: now, stats: { total: stars.length, byKind: kinds,
+    forgettingSoon: stars.filter(star => star.retention < 0.3).length }, stars, links, review };
+  const html = renderHtml(payload, title);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${randomBytes(5).toString('hex')}.tmp`;
+  try {
+    fs.writeFileSync(temporary, html, { flag: 'wx', mode: 0o600 });
+    fs.renameSync(temporary, file);
+  } finally {
+    try { fs.unlinkSync(temporary); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  return { file, total: stars.length, edges: links.length, kinds, bytes: Buffer.byteLength(html), elapsedMs: performance.now() - started };
+}
+
+export function mapReport(result) {
+  const kinds = Object.entries(result.kinds).map(([kind, count]) => `${kind} ${count}`).join(' / ');
+  return `已生成记忆神经网络图\n- 节点 ${result.total} 个${kinds ? `（${kinds}）` : ''}\n- 关联边 ${result.edges} 条\n`
+    + `- 文件：${result.file}（${(result.bytes / 1024 / 1024).toFixed(2)} MB）\n双击打开即可（断网也能看）`;
+}
+
+export function openMap(file) {
+  const command = process.platform === 'win32' ? 'rundll32.exe' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['url.dll,FileProtocolHandler', pathToFileURL(file).href] : [file];
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { windowsHide: true, stdio: 'ignore' });
+    child.once('error', reject);
+    child.once('exit', code => code === 0 ? resolve() : reject(new Error(`浏览器启动失败：退出码 ${code}`)));
+  });
+}

package/lib/recall.js

@@ -0,0 +1,59 @@
+import { chars, retention, titleOf } from './decay.js';
+
+export function relevance(memory, query) {
+  const q = query.trim().toLocaleLowerCase();
+  if (!q) return 0;
+  const title = titleOf(memory).toLocaleLowerCase();
+  const text = memory.text.toLocaleLowerCase();
+  const terms = q.split(/[\s\p{P}\p{S}]+/u).filter(term => Array.from(term).length >= 2);
+  let rel = 0;
+  for (const term of terms) {
+    if (title.includes(term)) rel += 3;
+    if (text.includes(term)) rel += 2;
+    if (title.startsWith(term)) rel += 2;
+  }
+  if (title.includes(q)) rel += 4;
+  if (text.includes(q)) rel += 2;
+  return rel;
+}
+
+function related(a, b) {
+  return [a.title, a.prefix].some(key => key && b.text.includes(key))
+    || [b.title, b.prefix].some(key => key && a.text.includes(key));
+}
+
+export function recall(memories, { q, limit = 8, hops = 1, kind }, now = Date.now()) {
+  if (typeof q !== 'string' || !q.trim()) throw new Error('q 必须是非空字符串');
+  limit = Math.max(1, Math.min(20, Math.trunc(Number.isFinite(limit) ? limit : 8)));
+  hops = Math.max(0, Math.min(2, Math.trunc(Number.isFinite(hops) ? hops : 1)));
+  const pool = memories.filter(memory => kind === undefined || memory.kind === kind)
+    .map(memory => ({ memory, retention: retention(memory, now),
+      title: titleOf(memory), prefix: chars(memory.text, 12), text: memory.text }));
+  const sorted = rows => rows.sort((a, b) => b.score - a.score || b.memory.ts - a.memory.ts);
+  const direct = sorted(pool.map(row => ({ ...row, rel: relevance(row.memory, q), via: 'direct' }))
+    .filter(row => row.rel > 0).map(row => ({ ...row, score: row.rel * (0.35 + 0.65 * row.retention) })))
+    .slice(0, limit);
+  const best = new Map(direct.map(row => [row.memory.id, row]));
+  let frontier = direct;
+  for (let hop = 0; hop < hops; hop++) {
+    const next = new Map();
+    // Lower-scored paths only decay further, so they cannot enter the final
+    // top N once their best possible next score is below its existing floor.
+    const floor = best.size >= limit ? sorted([...best.values()])[limit - 1].score : 0;
+    for (const source of frontier) {
+      if (source.score * 0.45 < floor) continue;
+      for (const neighbor of pool) {
+        if (neighbor.memory.id === source.memory.id || neighbor.retention <= 0.4
+          || !related(source, neighbor)) continue;
+        const score = source.score * 0.45;
+        if (score <= (best.get(neighbor.memory.id)?.score ?? 0)) continue;
+        const hit = { ...neighbor, score, via: 'spread' };
+        best.set(neighbor.memory.id, hit);
+        next.set(neighbor.memory.id, hit);
+      }
+    }
+    frontier = [...next.values()];
+  }
+  return sorted([...best.values()]).slice(0, limit)
+    .map(({ memory, score, retention: value, via }) => ({ ...memory, score, retention: value, via }));
+}

package/lib/render/index.mjs

@@ -0,0 +1,22 @@
+import { loadMemories } from './load.mjs';
+import { scoreMemories } from './score.mjs';
+import { layoutMemories } from './layout.mjs';
+import { renderHtml } from './render.mjs';
+
+export { loadMemories, scoreMemories, layoutMemories, renderHtml };
+
+export async function generate(input, { title = '记忆神经网络', now = Date.now() } = {}) {
+  const items = await loadMemories(input, now);
+  const { nodes, links, review } = scoreMemories(items, now);
+  const stars = layoutMemories(nodes);
+  const payload = {
+    generatedAt: now,
+    stats: {
+      total: stars.length,
+      byKind: stars.reduce((counts, star) => ({ ...counts, [star.kind]: (counts[star.kind] || 0) + 1 }), {}),
+      forgettingSoon: stars.filter((star) => star.retention < 0.3).length,
+    },
+    stars, links, review,
+  };
+  return { payload, html: renderHtml(payload, title) };
+}

package/lib/render/layout.mjs

@@ -0,0 +1,22 @@
+export function layoutMemories(nodes) {
+  let seed = 20261030;
+  const random = () => ((seed = (seed * 16807) % 2147483647) - 1) / 2147483646;
+  function brainPoint(radiusScale) {
+    const radius = Math.pow(random(), 1 / 3) * radiusScale;
+    const theta = random() * Math.PI * 2;
+    const phi = Math.acos(2 * random() - 1);
+    return {
+      x: radius * Math.sin(phi) * Math.cos(theta) * 1.18,
+      y: radius * Math.cos(phi) * 0.92,
+      z: radius * Math.sin(phi) * Math.sin(theta) * 0.78,
+    };
+  }
+  return nodes.map((node) => {
+    const inner = ['人格', '印象', '知识'].includes(node.kind) || node.majorEmotion;
+    const distance = inner ? 14 + Math.pow(random(), 0.65) * 36 : 48 + Math.min(1, node.ageDays / 30) * 58 + random() * 12;
+    const baseRadius = node.majorEmotion ? 3.2 : inner
+      ? (node.heat === 1 ? 2.4 : node.heat === 2 ? 1.8 : 1.3)
+      : (node.heat === 1 ? 2.1 : node.heat === 2 ? 1.5 : 1.0);
+    return { ...node, pos: brainPoint(distance), radius: baseRadius + Math.min(1.4, Math.sqrt(node.degree) * 0.18) };
+  });
+}

package/lib/render/load.mjs

@@ -0,0 +1,68 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+const short = (text, length) => [...text].slice(0, length).join('');
+
+function normalize(item, source, now) {
+  if (!item || typeof item !== 'object' || Array.isArray(item)) throw new Error(`${source}: 记忆必须是对象`);
+  if (typeof item.text !== 'string' || !item.text.trim()) throw new Error(`${source}: text 必须是非空字符串`);
+  const text = item.text.trim();
+  const id = String(item.id ?? source).trim();
+  if (!id) throw new Error(`${source}: id 不能为空`);
+  const date = item.ts == null ? new Date(now) : new Date(item.ts);
+  if (!Number.isFinite(date.getTime())) throw new Error(`${source}: ts 不是有效时间`);
+  const heat = item.heat == null || item.heat === '' ? undefined : Number(item.heat);
+  if (heat !== undefined && ![1, 2, 3].includes(heat)) throw new Error(`${source}: heat 必须是 1、2 或 3`);
+  return { id, text, ts: date.toISOString(), kind: String(item.kind ?? '记忆').trim() || '记忆', title: String(item.title ?? short(text, 20)).trim() || short(text, 20), heat };
+}
+
+function frontMatter(content) {
+  if (!content.startsWith('---\n') && !content.startsWith('---\r\n')) return { fields: {}, text: content };
+  const lines = content.split(/\r?\n/);
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+  if (end < 0) throw new Error('front-matter 缺少结束的 ---');
+  const fields = {};
+  for (const line of lines.slice(1, end)) {
+    const match = /^([\w-]+):\s*(.*)$/.exec(line);
+    if (!match) continue;
+    let value = match[2].trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) value = value.slice(1, -1);
+    fields[match[1]] = value;
+  }
+  return { fields, text: lines.slice(end + 1).join('\n') };
+}
+
+async function markdownFiles(directory) {
+  const files = [];
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const full = path.join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...await markdownFiles(full));
+    else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) files.push(full);
+  }
+  return files.sort((left, right) => left.localeCompare(right));
+}
+
+export async function loadMemories(input, now = Date.now()) {
+  const info = await stat(input);
+  let items;
+  if (info.isDirectory()) {
+    const files = await markdownFiles(input);
+    items = await Promise.all(files.map(async (file) => {
+      const { fields, text } = frontMatter(await readFile(file, 'utf8'));
+      const relative = path.relative(input, file).split(path.sep).join('/');
+      const fileInfo = await stat(file);
+      return normalize({ ...fields, id: fields.id ?? relative, title: fields.title ?? path.basename(file, path.extname(file)), ts: fields.ts ?? fileInfo.mtime.toISOString(), text }, relative, now);
+    }));
+  } else if (info.isFile() && path.extname(input).toLowerCase() === '.json') {
+    const parsed = JSON.parse(await readFile(input, 'utf8'));
+    if (!Array.isArray(parsed)) throw new Error('JSON 根节点必须是记忆数组');
+    items = parsed.map((item, index) => normalize(item, `第 ${index + 1} 条`, now));
+  } else throw new Error('输入必须是 JSON 文件或 Markdown 目录');
+  if (!items.length) throw new Error('没有找到记忆');
+  const ids = new Set();
+  for (const item of items) {
+    if (ids.has(item.id)) throw new Error(`重复的 id: ${item.id}`);
+    ids.add(item.id);
+  }
+  return items;
+}

package/lib/render/render.mjs

@@ -0,0 +1,222 @@
+function escapeHtml(value) {
+  return String(value).replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character]);
+}
+
+export function renderHtml(data, title = '记忆神经网络') {
+  const embedded = JSON.stringify(data).replace(/</g, '\\u003c').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+  const safeTitle = escapeHtml(title);
+  return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${safeTitle}</title>
+<style>
+  :root{color-scheme:dark}*{box-sizing:border-box}html,body{margin:0;width:100%;height:100%}
+  body{overflow:hidden;background:#03060c;color:#d8e9f8;font:13px/1.65 system-ui,"Microsoft YaHei",sans-serif}
+  canvas{display:block;touch-action:none;cursor:grab}canvas:active{cursor:grabbing}
+  .hud{position:fixed;top:16px;left:18px;pointer-events:none;text-shadow:0 0 12px #3388bb88}
+  .hud strong{color:#a4e6ff;font-size:16px}.sub{color:#7491a8;font-size:12px}
+  .panel,.review{position:fixed;background:#07111fee;border:1px solid #3976a055;border-radius:14px;box-shadow:0 0 40px #1763a033;padding:15px;backdrop-filter:blur(8px)}
+  .panel{display:none;top:16px;right:18px;width:min(350px,calc(100vw - 36px));max-height:78vh;overflow:auto}
+  .panel h2{font-size:16px;color:#b7e9ff;margin:5px 0}.panel .meta{color:#8ba8c2;margin:7px 0}.panel .text{white-space:pre-wrap;overflow-wrap:anywhere}
+  .close{float:right;border:0;background:transparent;color:#a4bad0;font-size:18px;cursor:pointer}
+  .review{bottom:16px;left:18px;width:min(400px,calc(100vw - 36px));max-height:32vh;overflow:auto;font-size:12px}
+  .review h2{font-size:14px;color:#ffdb82;margin:0 0 8px}.row{display:flex;gap:7px;align-items:center;margin:5px 0;color:#b1c6d9}
+  .row .name{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.bar{width:52px;height:5px;border-radius:5px;background:#335066;overflow:hidden}.bar i{display:block;height:100%;background:#6bc9fa}
+  .tip{position:fixed;right:18px;bottom:18px;color:#7b99ad;pointer-events:none}
+  @media(max-width:700px){.hud{top:8px;left:10px}.hud .sub,.tip{display:none}.review{left:10px;bottom:10px;max-height:24vh}.panel{top:8px;right:8px;max-height:55vh}}
+</style>
+</head>
+<body>
+<canvas id="map" aria-label="记忆神经网络"></canvas>
+<div class="hud"><strong>${safeTitle}</strong><div><span id="total"></span> 个神经元 · <span id="linkCount"></span> 条突触</div><div class="sub">大小＝重要度和连接数 · 亮度＝留存</div></div>
+<section class="panel" id="panel"><button class="close" id="close" aria-label="关闭">×</button><div id="kind"></div><h2 id="title"></h2><div class="meta" id="meta"></div><div class="text" id="body"></div></section>
+<section class="review"><h2>复习清单 · 留存最低的记忆</h2><div id="reviewList"></div></section>
+<div class="tip">拖拽旋转 · 滚轮缩放 · 点击查看记忆</div>
+<script>
+const DATA = ${embedded};
+const canvas = document.getElementById('map');
+const ctx = canvas.getContext('2d', { alpha: false });
+const colors = { '人格':[255,215,106], '印象':[143,216,255], '知识':[126,231,178], '日记':[190,160,255], '对话':[255,160,140], '情绪':[255,90,90] };
+const fallback = [145,205,255];
+const byId = new Map(DATA.stars.map(star => [star.id, star]));
+const adjacency = new Map(DATA.stars.map(star => [star.id, []]));
+for (const [left,right] of DATA.links) {
+  if (adjacency.has(left) && adjacency.has(right)) { adjacency.get(left).push(right); adjacency.get(right).push(left); }
+}
+const hubs = DATA.stars.filter(star => star.degree > 0).sort((left,right) => right.degree-left.degree).slice(0,6);
+const pulses = [];
+const firing = new Map();
+let seed = 987654321;
+const random = () => ((seed = seed * 16807 % 2147483647) - 1) / 2147483646;
+for (const star of DATA.stars) {
+  star._rgb = colors[star.kind] || fallback;
+  const count = Math.min(9, 4 + Math.round(Math.sqrt(star.degree) * 1.2));
+  star._dendrites = Array.from({length:count},(_,index) => ({
+    angle:index/count*Math.PI*2+random()*0.7,
+    length:0.9+random()*1.5, bend:(random()-0.5)*0.9, width:0.5+random()*0.7,
+    fork:random()<0.55 ? (random()-0.5)*1.5 : null
+  }));
+}
+function glowSprite(rgb) {
+  const off = document.createElement('canvas');
+  off.width = off.height = 96;
+  const brush = off.getContext('2d');
+  const gradient = brush.createRadialGradient(48,48,1,48,48,48);
+  gradient.addColorStop(0,'rgba('+rgb.join(',')+',0.7)');
+  gradient.addColorStop(0.4,'rgba('+rgb.join(',')+',0.19)');
+  gradient.addColorStop(1,'rgba('+rgb.join(',')+',0)');
+  brush.fillStyle = gradient; brush.fillRect(0,0,96,96);
+  return off;
+}
+const sprites = new Map();
+for (const star of DATA.stars) {
+  const key = star._rgb.join(',');
+  if (!sprites.has(key)) sprites.set(key,glowSprite(star._rgb));
+  star._glow = sprites.get(key);
+}
+let width=0,height=0,dpr=1,rotX=0.3,rotY=0.15,zoom=DATA.stars.length<50?1.6:1,autoSpin=true;
+function resize() {
+  width=innerWidth; height=innerHeight; dpr=Math.min(1.5,devicePixelRatio||1);
+  canvas.width=Math.round(width*dpr); canvas.height=Math.round(height*dpr);
+  canvas.style.width=width+'px'; canvas.style.height=height+'px';
+  ctx.setTransform(dpr,0,0,dpr,0,0);
+}
+addEventListener('resize',resize); resize();
+let drag=null;
+canvas.addEventListener('pointerdown',event => { autoSpin=false; drag={x:event.clientX,y:event.clientY,moved:0}; canvas.setPointerCapture(event.pointerId); });
+canvas.addEventListener('pointermove',event => {
+  if (!drag) return;
+  const dx=event.clientX-drag.x,dy=event.clientY-drag.y;
+  drag.x=event.clientX; drag.y=event.clientY; drag.moved+=Math.abs(dx)+Math.abs(dy);
+  rotY+=dx*0.006; rotX=Math.max(-1.5,Math.min(1.5,rotX+dy*0.006));
+});
+canvas.addEventListener('pointerup',event => { if (drag && drag.moved<6) select(event.clientX,event.clientY); drag=null; });
+canvas.addEventListener('pointercancel',() => { drag=null; });
+canvas.addEventListener('wheel',event => { event.preventDefault(); zoom=Math.max(0.3,Math.min(4.5,zoom*(event.deltaY>0?0.92:1.08))); },{passive:false});
+document.getElementById('close').onclick=() => { document.getElementById('panel').style.display='none'; };
+document.getElementById('total').textContent=DATA.stats.total;
+document.getElementById('linkCount').textContent=DATA.links.length;
+for (const [index,item] of DATA.review.entries()) {
+  const row=document.createElement('div'); row.className='row';
+  const name=document.createElement('span'); name.className='name'; name.textContent=(index+1)+'. ['+item.kind+'] '+item.title;
+  const bar=document.createElement('span'); bar.className='bar';
+  const fill=document.createElement('i'); fill.style.width=Math.min(100,Math.max(0,item.retention*100))+'%'; bar.append(fill);
+  row.append(name,bar); document.getElementById('reviewList').append(row);
+}
+function project(pos) {
+  const cy=Math.cos(rotY),sy=Math.sin(rotY),cx=Math.cos(rotX),sx=Math.sin(rotX);
+  const x=pos.x*cy-pos.z*sy,z=pos.x*sy+pos.z*cy;
+  const y=pos.y*cx-z*sx,depth=pos.y*sx+z*cx+250;
+  if (depth<=12) return null;
+  const scale=760/depth*zoom;
+  return {x:width/2+x*scale,y:height/2+y*scale,scale,depth};
+}
+function fire(id,now) {
+  firing.set(id,1);
+  for (const other of adjacency.get(id)||[]) {
+    firing.set(other,Math.max(0.65,firing.get(other)||0));
+    pulses.push({from:id,to:other,born:now,life:900+Math.random()*700});
+  }
+}
+function select(x,y) {
+  let best=null,distance=Infinity;
+  for (const star of DATA.stars) {
+    if (!star._screen) continue;
+    const value=Math.hypot(star._screen.x-x,star._screen.y-y);
+    if (value<star._screen.r && value<distance) {best=star;distance=value;}
+  }
+  if (!best) return;
+  fire(best.id,performance.now());
+  document.getElementById('panel').style.display='block';
+  document.getElementById('kind').textContent=best.kind;
+  document.getElementById('title').textContent=best.title;
+  document.getElementById('meta').textContent='重要度 '+best.heat+' · 留存 '+best.retention.toFixed(2)+' · 连接数 '+best.degree+(best.emotion.length?' · '+best.emotion.map(item=>item.tag).join('/'):'');
+  document.getElementById('body').textContent=best.text;
+}
+let nextFire=0,lastTime=0;
+function frame(now) {
+  const delta=Math.min(50,now-lastTime||16.7); lastTime=now;
+  if (autoSpin) rotY+=0.0011*delta/16.7;
+  if (now>nextFire) { nextFire=now+1000+Math.random()*1500; if (hubs.length) fire(hubs[Math.floor(Math.random()*hubs.length)].id,now); }
+  ctx.globalCompositeOperation='source-over'; ctx.fillStyle='#03060c'; ctx.fillRect(0,0,width,height);
+  ctx.strokeStyle='rgba(40,90,140,0.055)';ctx.lineWidth=1;
+  for (let index=0;index<20;index++) {
+    const y=index/20*height;
+    ctx.beginPath();ctx.moveTo(0,y);ctx.bezierCurveTo(width*.3,y+Math.sin(now*.0003+index)*30,width*.7,y-Math.cos(now*.00025+index)*30,width,y);ctx.stroke();
+  }
+  const points=[];
+  for (const star of DATA.stars) {
+    const p=project(star.pos);
+    if (!p || p.x< -100 || p.x>width+100 || p.y< -100 || p.y>height+100) {star._screen=null;continue;}
+    points.push({star,p});
+  }
+  points.sort((left,right)=>right.p.depth-left.p.depth);
+  const screen=new Map(points.map(point=>[point.star.id,point]));
+  ctx.globalCompositeOperation='lighter';
+  for (const [left,right] of DATA.links) {
+    const first=screen.get(left),second=screen.get(right);
+    if (!first||!second) continue;
+    const act=Math.max(firing.get(left)||0,firing.get(right)||0);
+    const alpha=Math.min(.85,.1*Math.min(first.star.retention,second.star.retention)+.35*act);
+    if (alpha<.01) continue;
+    const mx=(first.p.x+second.p.x)/2+(first.p.y-second.p.y)*.18;
+    const my=(first.p.y+second.p.y)/2+(second.p.x-first.p.x)*.18;
+    ctx.strokeStyle='rgba(110,190,255,'+alpha+')';ctx.lineWidth=.7+act*1.6;
+    ctx.beginPath();ctx.moveTo(first.p.x,first.p.y);ctx.quadraticCurveTo(mx,my,second.p.x,second.p.y);ctx.stroke();
+  }
+  for (let index=pulses.length-1;index>=0;index--) {
+    const pulse=pulses[index],fraction=(now-pulse.born)/pulse.life;
+    if (fraction>=1) {pulses.splice(index,1);continue;}
+    const first=screen.get(pulse.from),second=screen.get(pulse.to);
+    if (!first||!second) continue;
+    const mx=(first.p.x+second.p.x)/2+(first.p.y-second.p.y)*.18,my=(first.p.y+second.p.y)/2+(second.p.x-first.p.x)*.18;
+    const inverse=1-fraction;
+    const x=inverse*inverse*first.p.x+2*inverse*fraction*mx+fraction*fraction*second.p.x;
+    const y=inverse*inverse*first.p.y+2*inverse*fraction*my+fraction*fraction*second.p.y;
+    ctx.fillStyle='rgba(205,245,255,'+(.9*inverse)+')';ctx.beginPath();ctx.arc(x,y,2.5+2*inverse,0,Math.PI*2);ctx.fill();
+  }
+  for (const {star,p} of points) {
+    const act=firing.get(star.id)||0,ret=Math.max(.05,Math.min(1.2,star.retention));
+    const intensity=Math.min(1,.22+ret*.72)*(1+act*1.1);
+    const radius=Math.max(2,star.radius*p.scale*.55)*(1+Math.sin(now*.0016+(star.pos.x+star.pos.z)*.3)*.06)*(1+act*.5);
+    const rgb=star._rgb.join(',');
+    ctx.strokeStyle='rgba('+rgb+','+Math.min(1,.3*intensity)+')';
+    if (radius>2.5) for (const branch of star._dendrites) {
+      const length=radius*2.2*branch.length,dx=Math.cos(branch.angle),dy=Math.sin(branch.angle);
+      const ex=p.x+dx*length,ey=p.y+dy*length;
+      const cx=p.x+dx*length*.55-dy*length*branch.bend*.5;
+      const cy=p.y+dy*length*.55+dx*length*branch.bend*.5;
+      ctx.lineWidth=branch.width;ctx.beginPath();ctx.moveTo(p.x,p.y);ctx.quadraticCurveTo(cx,cy,ex,ey);ctx.stroke();
+      if (branch.fork!==null) {
+        const angle=branch.angle+branch.fork;
+        ctx.lineWidth=branch.width*.65;ctx.beginPath();ctx.moveTo(cx,cy);ctx.quadraticCurveTo(cx+Math.cos(angle)*length*.2,cy+Math.sin(angle)*length*.2,cx+Math.cos(angle)*length*.34,cy+Math.sin(angle)*length*.34);ctx.stroke();
+      }
+    }
+    const glowRadius=radius*3.6;
+    ctx.globalAlpha=Math.min(1,.4+intensity*.7);ctx.drawImage(star._glow,p.x-glowRadius,p.y-glowRadius,glowRadius*2,glowRadius*2);ctx.globalAlpha=1;
+    ctx.fillStyle='rgba('+rgb+','+Math.min(1,.42*intensity)+')';ctx.beginPath();ctx.arc(p.x,p.y,radius,0,Math.PI*2);ctx.fill();
+    ctx.strokeStyle='rgba('+rgb+','+Math.min(1,.75*intensity)+')';ctx.lineWidth=1;ctx.stroke();
+    ctx.fillStyle='rgba(255,255,255,'+Math.min(1,.6*intensity)+')';ctx.beginPath();ctx.arc(p.x,p.y,radius*.42,0,Math.PI*2);ctx.fill();
+    if (star.retention<.25) {
+      ctx.strokeStyle='rgba(255,110,110,'+Math.max(0,.45-star.retention)+')';ctx.setLineDash([3,4]);
+      ctx.beginPath();ctx.arc(p.x,p.y,radius*3.2,0,Math.PI*2);ctx.stroke();ctx.setLineDash([]);
+    }
+    star._screen={x:p.x,y:p.y,r:Math.max(8,radius*2.6)};
+  }
+  for (const [id,value] of firing) {
+    const next=value*Math.pow(.965,delta/16.7);
+    if (next<.02) firing.delete(id); else firing.set(id,next);
+  }
+  ctx.globalCompositeOperation='source-over';
+  const vignette=ctx.createRadialGradient(width/2,height/2,Math.min(width,height)*.34,width/2,height/2,Math.max(width,height)*.8);
+  vignette.addColorStop(0,'rgba(0,0,0,0)');vignette.addColorStop(1,'rgba(0,0,0,.78)');
+  ctx.fillStyle=vignette;ctx.fillRect(0,0,width,height);
+  requestAnimationFrame(frame);
+}
+requestAnimationFrame(frame);
+</script>
+</body>
+</html>`;
+}