dsh-memory-engine 0.7.7 → 0.8.1

package/README.md

@@ -1,8 +1,8 @@
 # DSH 记忆引擎
 
-[![npm](https://img.shields.io/badge/version-0.8.0-blue)](https://www.npmjs.com/package/dsh-memory-engine)
+[![npm](https://img.shields.io/badge/version-0.8.1-blue)](https://www.npmjs.com/package/dsh-memory-engine)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
-[![tests](https://img.shields.io/badge/tests-277%20passed-brightgreen)](test)
+[![tests](https://img.shields.io/badge/tests-291%20passed-brightgreen)](test)
 
 DSH 插件的本地记忆引擎，带神经网络可视化。它让 agent 保存、召回和管理跨会话记忆，也能把你已有的记忆文件导进来。
 
@@ -11,21 +11,48 @@ DSH 插件的本地记忆引擎，带神经网络可视化。它让 agent 保存
 
 ![记忆图谱](docs/screenshot.png)
 
-当前版本：0.8.0。Node ≥22，零新增依赖。新增四套配色与三种布局，默认保留原来的经典星空与球体。自动记忆默认关闭，由用户在图谱头部或设置页手动打开；开启后每轮对话会额外调用一次模型，可能产生费用。自动导入默认只收聊天会话的用户消息，支持来源白名单、工作指令过滤、流程话过滤、规则分类、错误原因、一次性重扫和账本清理。
+当前版本：0.8.1。Node ≥22，零新增依赖。四套配色与球体、星系、大脑神经网络三种布局自由组合，默认保留原来的经典星空与球体。自动记忆默认关闭，由用户在图谱头部或设置页手动打开；开启后每轮对话会额外调用一次模型，可能产生费用。自动导入默认只收聊天会话的用户消息，支持来源白名单、工作指令过滤、流程话过滤、规则分类、错误原因、一次性重扫和账本清理。
 
-## 0.8.0 图谱外观
+## 安装（重要）
+
+**请指定版本号安装。** pnpm 可能因为本地缓存的包元数据解析到旧版本（实测 `pnpm add dsh-memory-engine` 会装到 0.7.5）：
+
+```bash
+pnpm add dsh-memory-engine@0.8.1
+```
+
+装完重启 DSH，标题栏出现「🧠 记忆图谱」。
+
+0.7.5 及更早版本存在 `memory_map` 参数名撞 JSON Schema 保留字的问题，调用时整轮返回 400，请勿使用。
+
+## 0.8.1 图谱外观
 
 图谱头部点击「外观」，可组合选择四套配色与三种布局；「设置」页也有同一组选项。点选立即应用并保存，刷新后保留；保存失败会回滚并显示原因。「恢复默认」同时恢复经典星空和球体。
 
 | 维度 | 选项 |
 | --- | --- |
 | 配色 | 经典星空 `classic` / 赛博霓虹 `neon` / 铅绘素描 `paper` / 极简单色 `mono` |
-| 布局 | 球体 `sphere` / 平面圆 `flat` / 螺旋银河 `spiral` |
+| 布局 | 球体 `sphere` / 星系 `galaxy` / 大脑神经网络 `brain` |
+
+铅绘素描采用素纸底色、石墨灰节点和极淡光晕。星系有密集核心、2～4 条带抖动的旋臂和 30% 星尘；大脑神经网络有不对称的左右半球、每半球 12～14 个簇心、5% 游离节点和表面起伏。固定种子与节点 id 哈希保证相同数据的位置完全一致。三种布局都保留中心区域角色卡、旋转、缩放和点击详情；大脑角色卡位于纵裂中间偏下。切换时保留已选节点、相机及动画状态，不重新请求记忆数据，不改变记忆的重要度、留存或节点尺寸算法。星系仅将选中关联线的透明度和宽度降到球体的 80%，避免密集连线发白。
 
-铅绘素描采用素纸底色、石墨灰节点和极淡光晕。平面圆按连接数分为三个同心环；螺旋银河沿三条旋臂排列。三种布局都保留角色卡中心、旋转、缩放和点击详情。切换时保留已选节点、相机及动画状态，不重新请求记忆数据，不改变记忆的重要度、留存或节点尺寸算法。
+0.8.0 的旧配置自动兼容：`flat` 按 `galaxy` 读取，`spiral` 按 `brain` 读取，不需要手动改文件，也不在读取时写盘。旧客户端提交这两个旧值也会被接受，并通过原有备份和原子写保存为新值。界面只显示球体、星系、大脑神经网络三种选项。
 
 在现有配置中可合并 `"graphTheme": "classic"` 和 `"graphLayout": "sphere"`。这两个字段通过现有配置接口和备份、原子写流程保存，非法值返回 400。未配置时外观与升级前相同；没有角色卡的库仍保留原来的默认脑状布局。CLI 生成的离线图谱也读取同一配置。
 
+## 0.7.7 修复：工具参数名撞 JSON Schema 保留字
+
+`memory_map` 的 `title`、`memory_forget` 的 `id` 是 JSON Schema 的保留关键字。宿主如果没把参数表转换成完整 schema，直接把这些名字当关键字发送，DeepSeek 会整轮返回 400：
+
+```
+Invalid schema for function 'memory_map':
+{"type":"string","description":"页面标题..."} is not of type "string"
+```
+
+修复：改名为 `pageTitle` / `memoryId`，旧参数名仍作为别名兼容，已有调用不受影响。
+
+**给插件作者**：工具参数名不要用 JSON Schema 关键字——`title`、`description`、`type`、`id`、`$ref`、`enum`、`default`、`required`、`properties`、`items`、`additionalProperties` 等。宿主把参数表当 schema 解析时会直接报错。
+
 ## 从 0.6.1 升级到 0.7.0 的变化
 
 - 不再占用 18886 端口，改用 DSH 宿主的同源路由。

package/lib/client.js

@@ -54,7 +54,9 @@ window.__ModuleLoader__.load({
   if (!Object.hasOwn(THEMES, themeName)) throw new Error('未知图谱配色');
   let theme = THEMES[themeName];
   let layoutName = options.graphLayout ?? data.graphLayout ?? 'sphere';
-  if (!['sphere', 'flat', 'spiral'].includes(layoutName)) throw new Error('未知图谱布局');
+  if (layoutName === 'flat') layoutName = 'galaxy';
+  if (layoutName === 'spiral') layoutName = 'brain';
+  if (!['sphere', 'galaxy', 'brain'].includes(layoutName)) throw new Error('未知图谱布局');
   let sphereNodes = [];
   const layouts = new Map();
   let nodes = [], links = [], hubs = [], linkTwinkle = [], visibleLinks = [];
@@ -102,7 +104,9 @@ function glowSprite(rgb) {
 
   function setLayout(nextLayout) {
     if (destroyed) return;
-    if (!['sphere', 'flat', 'spiral'].includes(nextLayout)) throw new Error('未知图谱布局');
+    if (nextLayout === 'flat') nextLayout = 'galaxy';
+    if (nextLayout === 'spiral') nextLayout = 'brain';
+    if (!['sphere', 'galaxy', 'brain'].includes(nextLayout)) throw new Error('未知图谱布局');
     if (layoutName === nextLayout && layouts.has(nextLayout)) return;
     if (!layouts.has(nextLayout)) {
       if (typeof options.layoutNodes !== 'function') throw new Error('缺少图谱布局函数');
@@ -327,20 +331,22 @@ function frame(now) {
     }
   }
   if (linkPaths.length) {
+    if (layoutName === 'galaxy') ctx.globalAlpha=0.8;
     if (Array.isArray(theme.link)) {
       const gradient = ctx.createLinearGradient(0,0,width,height);
       gradient.addColorStop(0,theme.link[0]);
       gradient.addColorStop(1,theme.link[1]);
       ctx.strokeStyle=gradient;
     } else ctx.strokeStyle=theme.link;
-    ctx.lineWidth=1;
+    ctx.lineWidth=layoutName === 'galaxy' ? 0.8 : 1;
     ctx.beginPath();
     for (const p of linkPaths) { ctx.moveTo(p[0],p[1]); ctx.quadraticCurveTo(p[2],p[3],p[4],p[5]); }
     ctx.stroke();
     // 更亮的一层，让关联线看得清
     ctx.strokeStyle=theme.linkHighlight;
-    ctx.lineWidth=2;
+    ctx.lineWidth=layoutName === 'galaxy' ? 1.6 : 2;
     ctx.stroke();
+    if (layoutName === 'galaxy') ctx.globalAlpha=1;
   }
   for (let index=pulses.length-1;index>=0;index--) {
     const pulse=pulses[index],fraction=(now-pulse.born)/pulse.life;
@@ -473,7 +479,9 @@ function frame(now) {
 
 
     function layoutPositions(nodes, layout = 'sphere') {
-  if (!['sphere', 'flat', 'spiral'].includes(layout)) throw new Error('未知图谱布局');
+  if (layout === 'flat') layout = 'galaxy';
+  if (layout === 'spiral') layout = 'brain';
+  if (!['sphere', 'galaxy', 'brain'].includes(layout)) throw new Error('未知图谱布局');
   if (layout === 'sphere') return nodes.map(node => ({ ...node, pos: { ...node.pos } }));
   const memories = nodes.filter(node => !node.isCore).sort((left, right) =>
     (right.degree || 0) - (left.degree || 0) || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0));
@@ -484,25 +492,107 @@ function frame(now) {
     hash = Math.imul(hash ^ (hash >>> 16), 0x45d9f3b);
     return ((hash ^ (hash >>> 16)) >>> 0) / 4294967295 * 2 - 1;
   }
-  if (layout === 'flat') {
-    for (let ring = 0; ring < 3; ring++) {
-      const members = memories.slice(Math.ceil(memories.length * ring / 3), Math.ceil(memories.length * (ring + 1) / 3));
-      const radius = [30, 55, 80][ring];
-      members.forEach((node, index) => {
-        const angle = index / members.length * Math.PI * 2;
-        positions.set(node.id, { x: Math.cos(angle) * radius + jitter(node.id, 'x') * 3,
-          y: Math.sin(angle) * radius + jitter(node.id, 'y') * 3, z: 0 });
-      });
-    }
-  } else {
+  let datasetSeed = 20261030;
+  for (const id of memories.map(node => String(node.id)).sort()) {
+    for (const character of id + '\u0000') datasetSeed = Math.imul(datasetSeed ^ character.codePointAt(0), 16777619);
+  }
+  const uniform = (id, axis) => Math.max(1e-9, Math.min(1 - 1e-9, (jitter(datasetSeed + ':' + id, axis) + 1) / 2));
+  const gaussian = (id, axis) => Math.sqrt(-2 * Math.log(uniform(id, axis + ':radius'))) * Math.cos(2 * Math.PI * uniform(id, axis + ':angle'));
+  if (layout === 'galaxy') {
+    const armCount = 2 + Math.floor(uniform('galaxy', 'arms') * 3);
+    const rotation = uniform('galaxy', 'rotation') * Math.PI * 2;
+    const coreCount = Math.ceil(memories.length * 0.15);
+    const haloCount = Math.floor(memories.length * 0.05);
+    const diskEnd = memories.length - haloCount;
+    const dustCount = Math.round(memories.length * 0.30);
+    const dust = new Set(memories.slice(coreCount, diskEnd)
+      .sort((left, right) => uniform(left.id, 'dust') - uniform(right.id, 'dust') || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0))
+      .slice(0, Math.max(0, dustCount - haloCount)).map(node => node.id));
     memories.forEach((node, index) => {
-      const fraction = index / Math.max(1, memories.length - 1);
-      const angle = fraction * 3.2 * Math.PI + index % 3 * Math.PI * 2 / 3 + jitter(node.id, 'angle') * 0.35;
-      const radius = 18 + fraction * 92;
-      positions.set(node.id, { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius, z: jitter(node.id, 'z') * 14 });
+      let radius, angle;
+      if (index < coreCount) {
+        radius = 6 + Math.sqrt(uniform(node.id, 'core-radius')) * 16;
+        angle = uniform(node.id, 'core-angle') * Math.PI * 2;
+      } else if (index >= diskEnd) {
+        radius = 95 + Math.sqrt(uniform(node.id, 'halo-radius')) * 35;
+        angle = uniform(node.id, 'halo-angle') * Math.PI * 2;
+      } else if (dust.has(node.id)) {
+        radius = 22 + Math.sqrt(uniform(node.id, 'dust-radius')) * 73;
+        angle = uniform(node.id, 'dust-angle') * Math.PI * 2;
+      } else {
+        const fraction = (index - coreCount + 0.5) / Math.max(1, diskEnd - coreCount);
+        const offset = fraction * 73 + gaussian(node.id, 'radius') * 9;
+        const folded = ((offset % 146) + 146) % 146;
+        radius = 22 + (folded <= 73 ? folded : 146 - folded);
+        const arm = Math.floor(uniform(node.id, 'arm') * armCount);
+        const base = rotation + arm * Math.PI * 2 / armCount + (uniform(arm, 'arm-offset') - 0.5) * 0.35;
+        const twist = (radius - 18) / 95 * 2.2 * Math.PI;
+        const ripple = Math.sin(radius * 0.055 + uniform(arm, 'phase') * Math.PI * 2) * 0.10;
+        angle = base + twist + ripple + gaussian(node.id, 'angle') * 0.30;
+      }
+      const thickness = 8 / (1 + radius / 40);
+      const height = Math.max(-1, Math.min(1, gaussian(node.id, 'height') * 0.5)) * thickness;
+      positions.set(node.id, { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius, z: height });
+    });
+  } else {
+    function brainPoint(id, axis, extent = 1) {
+      const horizontal = gaussian(id, axis + ':x');
+      const vertical = gaussian(id, axis + ':y');
+      const depth = gaussian(id, axis + ':z');
+      const scale = Math.cbrt(uniform(id, axis + ':distance')) * extent / Math.hypot(horizontal, vertical, depth);
+      return { x: 42 + horizontal * scale * 40, y: vertical * scale * 106, z: depth * scale * 52 };
+    }
+    const centers = [0, 1].map(side => {
+      const count = 12 + Math.floor(uniform('brain:' + side, 'clusters') * 3);
+      const candidates = Array.from({ length: 96 }, (_, index) => {
+        const id = 'brain:' + side + ':' + index;
+        const point = brainPoint(id, 'center', 0.82 + uniform(id, 'surface') * 0.12);
+        return { ...point, spread: 6 + uniform(id, 'spread') * 8, phase: uniform(id, 'phase') * Math.PI * 2 };
+      });
+      const interior = candidates.reduce((best, point, index) => Math.hypot(point.x - 42, point.y, point.z)
+        < Math.hypot(candidates[best].x - 42, candidates[best].y, candidates[best].z) ? index : best, 0);
+      const selected = [candidates.splice(interior, 1)[0]];
+      while (selected.length < count) {
+        let best = 0, greatest = -Infinity;
+        candidates.forEach((point, index) => {
+          const distance = Math.min(...selected.map(center => Math.hypot(point.x - center.x, point.y - center.y, (point.z - center.z) * 0.7)));
+          if (distance > greatest) { greatest = distance; best = index; }
+        });
+        selected.push(candidates.splice(best, 1)[0]);
+      }
+      return selected;
+    });
+    const roamers = new Set([...memories].sort((left, right) => uniform(left.id, 'roaming') - uniform(right.id, 'roaming')
+      || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0))
+      .slice(0, Math.round(memories.length * 0.05)).map(node => node.id));
+    memories.forEach(node => {
+      const side = uniform(node.id, 'hemisphere') < 0.5 ? 0 : 1;
+      const target = brainPoint(node.id, 'target');
+      let center, nearest = Infinity;
+      centers[side].forEach((candidate, index) => {
+        const distance = Math.hypot(target.x - candidate.x, target.y - candidate.y, target.z - candidate.z)
+          * (0.8 + uniform(node.id, 'weight:' + index) * 0.4);
+        if (distance < nearest) { nearest = distance; center = candidate; }
+      });
+      const point = roamers.has(node.id) ? target : {
+        x: center.x + gaussian(node.id, 'scatter:x') * center.spread,
+        y: center.y + gaussian(node.id, 'scatter:y') * center.spread,
+        z: center.z + gaussian(node.id, 'scatter:z') * center.spread,
+      };
+      point.x += Math.sin(point.y * 0.08 + center.phase) * 6;
+      point.z += Math.sin(point.y * 0.09 + center.phase) * 4;
+      point.y += Math.sin(point.z * 0.12 + center.phase) * 3;
+      const envelope = 0.96 + 0.06 * Math.sin(point.y * 0.08) + 0.035 * Math.cos(point.z * 0.11 + side);
+      const distance = Math.hypot((point.x - 42) / 40, point.y / 106, point.z / 52);
+      if (distance > envelope) {
+        const scale = envelope * (0.93 + uniform(node.id, 'edge') * 0.06) / distance;
+        point.x = 42 + (point.x - 42) * scale; point.y *= scale; point.z *= scale;
+      }
+      positions.set(node.id, { x: (side ? 1 : -1) * (4 + Math.abs(point.x)) + (side ? 2 : 0),
+        y: point.y - (side ? 1 : 0), z: point.z });
     });
   }
-  return nodes.map(node => ({ ...node, pos: node.isCore ? { x: 0, y: 0, z: 0 } : positions.get(node.id) }));
+  return nodes.map(node => ({ ...node, pos: node.isCore ? { x: 0, y: layout === 'brain' ? 14 : 0, z: 0 } : positions.get(node.id) }));
 }
 
     var defaultSettings = { hideButton: false, showGuideOnEmpty: true, graphTheme: "classic", graphLayout: "sphere", autoMemory: { enabled: false, maxPerTurn: 2, dailyCap: 40 }, showAutoMemoryCostHint: true };
@@ -511,7 +601,7 @@ function frame(now) {
     var kinds = ["知识", "印象", "对话", "事件", "日记"];
     var appearanceOptions = [
       { key: "graphTheme", label: "配色", choices: [["classic", "经典星空"], ["neon", "赛博霓虹"], ["paper", "铅绘素描"], ["mono", "极简单色"]] },
-      { key: "graphLayout", label: "布局", choices: [["sphere", "球体"], ["flat", "平面圆"], ["spiral", "螺旋银河"]] },
+      { key: "graphLayout", label: "布局", choices: [["sphere", "球体"], ["galaxy", "星系"], ["brain", "大脑神经网络"]] },
     ];
     var appearanceStyles = {
       classic: {},

package/lib/client.src.js

@@ -22,7 +22,7 @@ window.__ModuleLoader__.load({
     var kinds = ["知识", "印象", "对话", "事件", "日记"];
     var appearanceOptions = [
       { key: "graphTheme", label: "配色", choices: [["classic", "经典星空"], ["neon", "赛博霓虹"], ["paper", "铅绘素描"], ["mono", "极简单色"]] },
-      { key: "graphLayout", label: "布局", choices: [["sphere", "球体"], ["flat", "平面圆"], ["spiral", "螺旋银河"]] },
+      { key: "graphLayout", label: "布局", choices: [["sphere", "球体"], ["galaxy", "星系"], ["brain", "大脑神经网络"]] },
     ];
     var appearanceStyles = {
       classic: {},

package/lib/config-write.js

@@ -16,7 +16,7 @@ const writable = new Map([
   ['autoMemory.dailyCap', value => Number.isSafeInteger(value) && value >= 0 && value <= 500],
   ['spinSpeed', value => Number.isFinite(value) && value >= 0.05 && value <= 1.5],
   ['graphTheme', value => ['classic', 'neon', 'paper', 'mono'].includes(value)],
-  ['graphLayout', value => ['sphere', 'flat', 'spiral'].includes(value)],
+  ['graphLayout', value => ['sphere', 'galaxy', 'brain', 'flat', 'spiral'].includes(value)],
   ['showGuideOnEmpty', value => typeof value === 'boolean'],
   ['hideButton', value => typeof value === 'boolean'],
 ]);
@@ -61,6 +61,10 @@ export function updateConfig(home, changes, { now = Date.now, warn = () => {} }
     try { next.autoImport.sessionFilter = normalizeSessionFilter({ ...current.autoImport?.sessionFilter, ...changes.autoImport.sessionFilter }); }
     catch (error) { invalid(error.message); }
   }
+  if (Object.hasOwn(changes, 'graphLayout')) {
+    if (next.graphLayout === 'flat') next.graphLayout = 'galaxy';
+    if (next.graphLayout === 'spiral') next.graphLayout = 'brain';
+  }
   if (changes.autoMemory?.enabled === true) next.showAutoMemoryCostHint = false;
   fs.mkdirSync(directory, { recursive: true });
   const prefix = `config.json.bak-${now()}`;

package/lib/config.js

@@ -53,7 +53,9 @@ export function readConfig(home = defaultHome(), { warn } = {}) {
     if (value.spinSpeed !== undefined && (!Number.isFinite(value.spinSpeed) || value.spinSpeed < 0.05 || value.spinSpeed > 1.5)) {
       throw new Error('spinSpeed 必须是 0.05～1.5 的数字');
     }
-    for (const [key, choices] of [['graphTheme', ['classic', 'neon', 'paper', 'mono']], ['graphLayout', ['sphere', 'flat', 'spiral']]]) {
+    if (value.graphLayout === 'flat') value.graphLayout = 'galaxy';
+    if (value.graphLayout === 'spiral') value.graphLayout = 'brain';
+    for (const [key, choices] of [['graphTheme', ['classic', 'neon', 'paper', 'mono']], ['graphLayout', ['sphere', 'galaxy', 'brain']]]) {
       if (value[key] !== undefined && !choices.includes(value[key])) throw new Error(`${key} 必须是 ${choices.join('、')}`);
     }
     return { ...value, personaTitle: value.personaTitle?.trim() || '角色卡', spinSpeed: value.spinSpeed ?? 0.35,

package/lib/render/canvas.js

@@ -38,7 +38,9 @@ export function createRenderer(canvas, data, options = {}) {
   if (!Object.hasOwn(THEMES, themeName)) throw new Error('未知图谱配色');
   let theme = THEMES[themeName];
   let layoutName = options.graphLayout ?? data.graphLayout ?? 'sphere';
-  if (!['sphere', 'flat', 'spiral'].includes(layoutName)) throw new Error('未知图谱布局');
+  if (layoutName === 'flat') layoutName = 'galaxy';
+  if (layoutName === 'spiral') layoutName = 'brain';
+  if (!['sphere', 'galaxy', 'brain'].includes(layoutName)) throw new Error('未知图谱布局');
   let sphereNodes = [];
   const layouts = new Map();
   let nodes = [], links = [], hubs = [], linkTwinkle = [], visibleLinks = [];
@@ -86,7 +88,9 @@ function glowSprite(rgb) {
 
   function setLayout(nextLayout) {
     if (destroyed) return;
-    if (!['sphere', 'flat', 'spiral'].includes(nextLayout)) throw new Error('未知图谱布局');
+    if (nextLayout === 'flat') nextLayout = 'galaxy';
+    if (nextLayout === 'spiral') nextLayout = 'brain';
+    if (!['sphere', 'galaxy', 'brain'].includes(nextLayout)) throw new Error('未知图谱布局');
     if (layoutName === nextLayout && layouts.has(nextLayout)) return;
     if (!layouts.has(nextLayout)) {
       if (typeof options.layoutNodes !== 'function') throw new Error('缺少图谱布局函数');
@@ -311,20 +315,22 @@ function frame(now) {
     }
   }
   if (linkPaths.length) {
+    if (layoutName === 'galaxy') ctx.globalAlpha=0.8;
     if (Array.isArray(theme.link)) {
       const gradient = ctx.createLinearGradient(0,0,width,height);
       gradient.addColorStop(0,theme.link[0]);
       gradient.addColorStop(1,theme.link[1]);
       ctx.strokeStyle=gradient;
     } else ctx.strokeStyle=theme.link;
-    ctx.lineWidth=1;
+    ctx.lineWidth=layoutName === 'galaxy' ? 0.8 : 1;
     ctx.beginPath();
     for (const p of linkPaths) { ctx.moveTo(p[0],p[1]); ctx.quadraticCurveTo(p[2],p[3],p[4],p[5]); }
     ctx.stroke();
     // 更亮的一层，让关联线看得清
     ctx.strokeStyle=theme.linkHighlight;
-    ctx.lineWidth=2;
+    ctx.lineWidth=layoutName === 'galaxy' ? 1.6 : 2;
     ctx.stroke();
+    if (layoutName === 'galaxy') ctx.globalAlpha=1;
   }
   for (let index=pulses.length-1;index>=0;index--) {
     const pulse=pulses[index],fraction=(now-pulse.born)/pulse.life;

package/lib/render/layout.mjs

@@ -1,7 +1,9 @@
 const SEED = 20261030;
 
 export function layoutPositions(nodes, layout = 'sphere') {
-  if (!['sphere', 'flat', 'spiral'].includes(layout)) throw new Error('未知图谱布局');
+  if (layout === 'flat') layout = 'galaxy';
+  if (layout === 'spiral') layout = 'brain';
+  if (!['sphere', 'galaxy', 'brain'].includes(layout)) throw new Error('未知图谱布局');
   if (layout === 'sphere') return nodes.map(node => ({ ...node, pos: { ...node.pos } }));
   const memories = nodes.filter(node => !node.isCore).sort((left, right) =>
     (right.degree || 0) - (left.degree || 0) || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0));
@@ -12,25 +14,107 @@ export function layoutPositions(nodes, layout = 'sphere') {
     hash = Math.imul(hash ^ (hash >>> 16), 0x45d9f3b);
     return ((hash ^ (hash >>> 16)) >>> 0) / 4294967295 * 2 - 1;
   }
-  if (layout === 'flat') {
-    for (let ring = 0; ring < 3; ring++) {
-      const members = memories.slice(Math.ceil(memories.length * ring / 3), Math.ceil(memories.length * (ring + 1) / 3));
-      const radius = [30, 55, 80][ring];
-      members.forEach((node, index) => {
-        const angle = index / members.length * Math.PI * 2;
-        positions.set(node.id, { x: Math.cos(angle) * radius + jitter(node.id, 'x') * 3,
-          y: Math.sin(angle) * radius + jitter(node.id, 'y') * 3, z: 0 });
-      });
-    }
-  } else {
+  let datasetSeed = 20261030;
+  for (const id of memories.map(node => String(node.id)).sort()) {
+    for (const character of id + '\u0000') datasetSeed = Math.imul(datasetSeed ^ character.codePointAt(0), 16777619);
+  }
+  const uniform = (id, axis) => Math.max(1e-9, Math.min(1 - 1e-9, (jitter(datasetSeed + ':' + id, axis) + 1) / 2));
+  const gaussian = (id, axis) => Math.sqrt(-2 * Math.log(uniform(id, axis + ':radius'))) * Math.cos(2 * Math.PI * uniform(id, axis + ':angle'));
+  if (layout === 'galaxy') {
+    const armCount = 2 + Math.floor(uniform('galaxy', 'arms') * 3);
+    const rotation = uniform('galaxy', 'rotation') * Math.PI * 2;
+    const coreCount = Math.ceil(memories.length * 0.15);
+    const haloCount = Math.floor(memories.length * 0.05);
+    const diskEnd = memories.length - haloCount;
+    const dustCount = Math.round(memories.length * 0.30);
+    const dust = new Set(memories.slice(coreCount, diskEnd)
+      .sort((left, right) => uniform(left.id, 'dust') - uniform(right.id, 'dust') || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0))
+      .slice(0, Math.max(0, dustCount - haloCount)).map(node => node.id));
     memories.forEach((node, index) => {
-      const fraction = index / Math.max(1, memories.length - 1);
-      const angle = fraction * 3.2 * Math.PI + index % 3 * Math.PI * 2 / 3 + jitter(node.id, 'angle') * 0.35;
-      const radius = 18 + fraction * 92;
-      positions.set(node.id, { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius, z: jitter(node.id, 'z') * 14 });
+      let radius, angle;
+      if (index < coreCount) {
+        radius = 6 + Math.sqrt(uniform(node.id, 'core-radius')) * 16;
+        angle = uniform(node.id, 'core-angle') * Math.PI * 2;
+      } else if (index >= diskEnd) {
+        radius = 95 + Math.sqrt(uniform(node.id, 'halo-radius')) * 35;
+        angle = uniform(node.id, 'halo-angle') * Math.PI * 2;
+      } else if (dust.has(node.id)) {
+        radius = 22 + Math.sqrt(uniform(node.id, 'dust-radius')) * 73;
+        angle = uniform(node.id, 'dust-angle') * Math.PI * 2;
+      } else {
+        const fraction = (index - coreCount + 0.5) / Math.max(1, diskEnd - coreCount);
+        const offset = fraction * 73 + gaussian(node.id, 'radius') * 9;
+        const folded = ((offset % 146) + 146) % 146;
+        radius = 22 + (folded <= 73 ? folded : 146 - folded);
+        const arm = Math.floor(uniform(node.id, 'arm') * armCount);
+        const base = rotation + arm * Math.PI * 2 / armCount + (uniform(arm, 'arm-offset') - 0.5) * 0.35;
+        const twist = (radius - 18) / 95 * 2.2 * Math.PI;
+        const ripple = Math.sin(radius * 0.055 + uniform(arm, 'phase') * Math.PI * 2) * 0.10;
+        angle = base + twist + ripple + gaussian(node.id, 'angle') * 0.30;
+      }
+      const thickness = 8 / (1 + radius / 40);
+      const height = Math.max(-1, Math.min(1, gaussian(node.id, 'height') * 0.5)) * thickness;
+      positions.set(node.id, { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius, z: height });
+    });
+  } else {
+    function brainPoint(id, axis, extent = 1) {
+      const horizontal = gaussian(id, axis + ':x');
+      const vertical = gaussian(id, axis + ':y');
+      const depth = gaussian(id, axis + ':z');
+      const scale = Math.cbrt(uniform(id, axis + ':distance')) * extent / Math.hypot(horizontal, vertical, depth);
+      return { x: 42 + horizontal * scale * 40, y: vertical * scale * 106, z: depth * scale * 52 };
+    }
+    const centers = [0, 1].map(side => {
+      const count = 12 + Math.floor(uniform('brain:' + side, 'clusters') * 3);
+      const candidates = Array.from({ length: 96 }, (_, index) => {
+        const id = 'brain:' + side + ':' + index;
+        const point = brainPoint(id, 'center', 0.82 + uniform(id, 'surface') * 0.12);
+        return { ...point, spread: 6 + uniform(id, 'spread') * 8, phase: uniform(id, 'phase') * Math.PI * 2 };
+      });
+      const interior = candidates.reduce((best, point, index) => Math.hypot(point.x - 42, point.y, point.z)
+        < Math.hypot(candidates[best].x - 42, candidates[best].y, candidates[best].z) ? index : best, 0);
+      const selected = [candidates.splice(interior, 1)[0]];
+      while (selected.length < count) {
+        let best = 0, greatest = -Infinity;
+        candidates.forEach((point, index) => {
+          const distance = Math.min(...selected.map(center => Math.hypot(point.x - center.x, point.y - center.y, (point.z - center.z) * 0.7)));
+          if (distance > greatest) { greatest = distance; best = index; }
+        });
+        selected.push(candidates.splice(best, 1)[0]);
+      }
+      return selected;
+    });
+    const roamers = new Set([...memories].sort((left, right) => uniform(left.id, 'roaming') - uniform(right.id, 'roaming')
+      || (String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0))
+      .slice(0, Math.round(memories.length * 0.05)).map(node => node.id));
+    memories.forEach(node => {
+      const side = uniform(node.id, 'hemisphere') < 0.5 ? 0 : 1;
+      const target = brainPoint(node.id, 'target');
+      let center, nearest = Infinity;
+      centers[side].forEach((candidate, index) => {
+        const distance = Math.hypot(target.x - candidate.x, target.y - candidate.y, target.z - candidate.z)
+          * (0.8 + uniform(node.id, 'weight:' + index) * 0.4);
+        if (distance < nearest) { nearest = distance; center = candidate; }
+      });
+      const point = roamers.has(node.id) ? target : {
+        x: center.x + gaussian(node.id, 'scatter:x') * center.spread,
+        y: center.y + gaussian(node.id, 'scatter:y') * center.spread,
+        z: center.z + gaussian(node.id, 'scatter:z') * center.spread,
+      };
+      point.x += Math.sin(point.y * 0.08 + center.phase) * 6;
+      point.z += Math.sin(point.y * 0.09 + center.phase) * 4;
+      point.y += Math.sin(point.z * 0.12 + center.phase) * 3;
+      const envelope = 0.96 + 0.06 * Math.sin(point.y * 0.08) + 0.035 * Math.cos(point.z * 0.11 + side);
+      const distance = Math.hypot((point.x - 42) / 40, point.y / 106, point.z / 52);
+      if (distance > envelope) {
+        const scale = envelope * (0.93 + uniform(node.id, 'edge') * 0.06) / distance;
+        point.x = 42 + (point.x - 42) * scale; point.y *= scale; point.z *= scale;
+      }
+      positions.set(node.id, { x: (side ? 1 : -1) * (4 + Math.abs(point.x)) + (side ? 2 : 0),
+        y: point.y - (side ? 1 : 0), z: point.z });
     });
   }
-  return nodes.map(node => ({ ...node, pos: node.isCore ? { x: 0, y: 0, z: 0 } : positions.get(node.id) }));
+  return nodes.map(node => ({ ...node, pos: node.isCore ? { x: 0, y: layout === 'brain' ? 14 : 0, z: 0 } : positions.get(node.id) }));
 }
 
 export function layoutMemories(nodes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-engine",
-  "version": "0.7.7",
+  "version": "0.8.1",
   "description": "DSH 本地记忆插件：自动记忆、遗忘曲线、关键词关联、可检索可编辑，数据留在本机。",
   "keywords": [
     "dsh",