dsh-memory-engine 0.6.1 → 0.7.0-beta.4

package/lib/config.js

@@ -8,14 +8,47 @@ export function resolveDiaryDir({ home = defaultHome(), envDir = process.env.QQ_
   return envDir || readConfig(home).diaryDir || '';
 }
 
+export function readUiConfig(home = defaultHome(), options = {}) {
+  const config = readConfig(home);
+  return { hideButton: config.hideButton === true, showGuideOnEmpty: config.showGuideOnEmpty !== false,
+    hasPersona: readPersona(config, options) !== null, personaTitle: config.personaTitle, spinSpeed: config.spinSpeed };
+}
+
+export function readPersona(config, { now = Date.now(), warn = message => console.warn(`[dsh-memory-engine] ${message}`) } = {}) {
+  if (config.personaText?.trim()) return { text: config.personaText, ts: now };
+  if (!config.personaFile?.trim()) return null;
+  let descriptor;
+  try {
+    descriptor = fs.openSync(config.personaFile, 'r');
+    const metadata = fs.fstatSync(descriptor);
+    if (!metadata.isFile()) throw new Error('角色卡路径不是普通文件');
+    const buffer = Buffer.alloc(16003);
+    const length = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+    const text = Array.from(buffer.subarray(0, length).toString('utf8').replace(/^\uFEFF/u, '')).slice(0, 4000).join('');
+    return text.trim() ? { text, ts: metadata.mtimeMs } : null;
+  } catch (error) {
+    try { warn(`读取角色卡失败，使用原布局：${error.message}`); } catch {}
+    return null;
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor);
+  }
+}
+
 export function readConfig(home = defaultHome()) {
   const file = path.join(home, 'memory-engine', 'config.json');
   try {
     const value = JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/u, ''));
     if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('配置必须是 JSON 对象');
-    return value;
+    for (const key of ['personaFile', 'personaText', 'personaTitle']) {
+      if (value[key] !== undefined && typeof value[key] !== 'string') throw new Error(`${key} 必须是字符串`);
+    }
+    if (value.personaText !== undefined && Array.from(value.personaText).length > 4000) throw new Error('personaText 最多 4000 字符');
+    if (value.spinSpeed !== undefined && (!Number.isFinite(value.spinSpeed) || value.spinSpeed < 0.05 || value.spinSpeed > 1.5)) {
+      throw new Error('spinSpeed 必须是 0.05～1.5 的数字');
+    }
+    return { ...value, personaTitle: value.personaTitle?.trim() || '角色卡', spinSpeed: value.spinSpeed ?? 0.35 };
   } catch (error) {
-    if (error.code === 'ENOENT') return {};
+    if (error.code === 'ENOENT') return { personaTitle: '角色卡', spinSpeed: 0.35 };
     throw new Error(`无法读取 ${file}：${error.message}`);
   }
 }

package/lib/index.js

@@ -1,10 +1,10 @@
 import { MemoryStore } from './store.js';
 import { chars, titleOf } from './decay.js';
 import { generateMap, mapReport, openMap } from './map.js';
-import { startMapServer } from './serve.js';
+import { registerMemoryRoutes } from './routes.js';
 
 export const name = 'memory-engine';
-export const inject = ['tools'];
+export const inject = ['tools', 'webServer'];
 
 function report(ctx, error) {
   try {
@@ -184,10 +184,9 @@ export function apply(ctx) {
         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());
+          disposers.push(registerMemoryRoutes(ctx.webServer, { store, warn: message => warn(ctx, message) }));
         } catch (error) {
-          warn(ctx, `图谱服务启动失败，记忆工具仍可用：${error.message}`);
+          warn(ctx, `图谱路由注册失败，记忆工具仍可用：${error.message}`);
         }
         const timer = setTimeout(() => {
           try { if (store.read().length > 0) generateMap(store); }

package/lib/map.js

@@ -4,7 +4,25 @@ 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';
+import { readConfig, readPersona } from './config.js';
+
+export function computeMapData(store, { warn } = {}) {
+  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 config = readConfig(path.dirname(path.dirname(store.file)));
+  const persona = readPersona(config, { now, warn });
+  const scored = scoreMemories(items, now);
+  const core = persona ? { id: 'persona', text: persona.text, title: config.personaTitle, kind: '人格', heat: 1,
+    ts: persona.ts, isCore: true, retention: 1, degree: 0, emotion: [], ageDays: 0, boosts: 0,
+    pos: { x: 0, y: 0, z: 0 }, radius: 6.5 } : null;
+  const nodes = layoutMemories(core ? [core, ...scored.nodes] : scored.nodes);
+  const kinds = Object.fromEntries([...new Set(nodes.map(node => node.kind))].map(kind => [kind, nodes.filter(node => node.kind === kind).length]));
+  return { generatedAt: now, nodes, links: scored.links, review: scored.review,
+    core: core ? { id: core.id, title: core.title, preview: Array.from(core.text).slice(0, 120).join('') + (Array.from(core.text).length > 120 ? '…' : '') } : null,
+    spinSpeed: config.spinSpeed,
+    stats: { total: nodes.length, byKind: kinds, forgettingSoon: nodes.filter(node => node.retention < 0.3).length } };
+}
 
 export function generateMap(store, { out, title = '我的记忆神经网络' } = {}) {
   const started = performance.now();
@@ -20,15 +38,8 @@ export function generateMap(store, { out, title = '我的记忆神经网络' } =
       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);
+  const { nodes, ...data } = computeMapData(store);
+  const html = renderHtml({ ...data, stars: nodes }, title);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const temporary = `${file}.${process.pid}.${randomBytes(5).toString('hex')}.tmp`;
   try {
@@ -37,7 +48,8 @@ export function generateMap(store, { out, title = '我的记忆神经网络' } =
   } 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 };
+  return { file, total: nodes.length, edges: data.links.length, kinds: data.stats.byKind,
+    bytes: Buffer.byteLength(html), elapsedMs: performance.now() - started };
 }
 
 export function mapReport(result) {

package/lib/onboard.js

@@ -0,0 +1,18 @@
+export const ONBOARD_PROMPT = [
+  '聊天时遇到这些，用 memory_save 记下来：',
+  '  · 对方的称呼、偏好、忌讳、习惯（kind="印象"，who 填对方名字）',
+  '  · 答应过的事、约定、承诺（kind="对话"）',
+  '  · 情绪特别重的瞬间（kind="事件"，heat=1）',
+  '  · 新学到的知识、名词、梗的解释（kind="知识"）',
+  '  · 每天结束时，用一两句写当天小结（kind="日记"）',
+  '',
+  '不用每条都记。一天三五条就够，宁可少存也别灌水。',
+  '存之前先 memory_recall 查一下，避免重复。',
+].join('\n');
+
+export const ONBOARD_STEPS = [
+  { title: '让机器人开始记', body: '把这段提示词加进机器人的角色卡或提示词里。' },
+  { title: '或者导入旧记忆', body: '在对话里说：「把 D:\\bot\\memories.json 导进记忆库」。支持 JSON、Markdown 和纯文本，先预览，确认后导入。' },
+  { title: '聊几句，回来点刷新', body: '有了新记忆后，点「刷新图谱」就能看到。' },
+];
+

package/lib/render/canvas.js

@@ -0,0 +1,348 @@
+export function createRenderer(canvas, data, options = {}) {
+  const document = canvas.ownerDocument;
+  const window = document.defaultView;
+  const performance = window.performance;
+  const ctx = canvas.getContext('2d', { alpha: false });
+  if (!ctx) throw new Error('Canvas 2D 不可用');
+  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];
+  let nodes = [], links = [], hubs = [], linkTwinkle = [];
+  const byId = new Map(), adjacency = new Map(), sprites = new Map();
+  const pulses = [], firing = new Map(), selections = new Set();
+  if (typeof options.onSelect === 'function') selections.add(options.onSelect);
+  let seed = 987654321;
+  const random = () => ((seed = seed * 16807 % 2147483647) - 1) / 2147483646;
+  let width=0,height=0,dpr=1,rotX=0.3,rotY=0.15,zoom=data.nodes.length<50?1.6:1,autoSpin=true;
+  let spinSpeed=data.spinSpeed??0.35,resumeAt=0;
+  let drag=null,nextFire=0,lastTime=0,rafId=null,running=false,destroyed=false,generation=0,observer=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;
+}
+
+  // 字符串 → 32 位无符号哈希。给连线的闪烁参数做种子：
+  // 用 id 而不是 Math.random，保证同一条线在每次打开时节奏一致（不会每次刷新都跳），
+  // 但不同连线之间互不同步。
+  function hashString(text) {
+    let hash = 2166136261;
+    for (let i = 0; i < text.length; i++) {
+      hash ^= text.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+  }
+
+  function setData(nextData) {
+    if (destroyed) return;
+    spinSpeed=nextData.spinSpeed??0.35;
+    nodes = nextData.nodes.map(node => ({ ...node, pos: { ...node.pos } }));
+    links = nextData.links.map(link => [...link]);
+    byId.clear(); adjacency.clear(); sprites.clear(); pulses.length = 0; firing.clear();
+    seed = 987654321; nextFire = 0;
+    for (const node of nextData.nodes) byId.set(node.id, node);
+    for (const node of nodes) adjacency.set(node.id, []);
+    for (const [left,right] of links) {
+      if (adjacency.has(left) && adjacency.has(right)) { adjacency.get(left).push(right); adjacency.get(right).push(left); }
+    }
+    hubs = nodes.filter(star => star.degree > 0).sort((left,right) => right.degree-left.degree).slice(0,6);
+    // 每条连线一份自己的闪烁参数：相位和频率都不一样，整体才不会"齐刷刷"地一起亮。
+    // 用连线两端 id 的哈希做种子，保证同一条线每次打开图的节奏一致（不会跳变），
+    // 但线与线之间互不同步。
+    linkTwinkle = links.map(([left, right]) => {
+      const h = hashString(left + '|' + right);
+      return {
+        // 频率调低：周期从 4~18 秒放慢到 18~55 秒，变成"慢慢呼吸"而不是"闪"
+        freq: 0.000114 + (h % 1000) / 1000 * 0.000235,
+        phase: (Math.floor(h / 1000) % 6283) / 1000,       // 0 ~ 6.28，彼此错开
+        amp: 0.05 + (Math.floor(h / 7e6) % 100) / 100 * 0.12,
+        // 弯曲：一半往左弯一半往右弯，弯度 8%~24%。
+        // 之前所有线都朝同一侧弯，视觉上像漩涡，边界区域就显空。
+        bow: (h % 2 === 0 ? 1 : -1) * (0.08 + (Math.floor(h / 13) % 100) / 100 * 0.16),
+        // 端点偏移：同一个节点被很多线连时，让它们从不同角度进来，散成扇面而不是叠成一条
+        jitterStart: ((Math.floor(h / 31) % 100) / 100 - 0.5) * 1.6,
+        jitterEnd: ((Math.floor(h / 977) % 100) / 100 - 0.5) * 1.6,
+      };
+    });
+for (const star of nodes) {
+  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
+  }));
+}
+for (const star of nodes) {
+  const key = star._rgb.join(',');
+  if (!sprites.has(key)) sprites.set(key,glowSprite(star._rgb));
+  star._glow = sprites.get(key);
+}
+
+  }
+
+  function resize() {
+    if (destroyed) return;
+    const bounds = canvas.getBoundingClientRect();
+    width=bounds.width; height=bounds.height; dpr=Math.min(1.5,window.devicePixelRatio||1);
+    canvas.width=Math.round(width*dpr); canvas.height=Math.round(height*dpr);
+    ctx.setTransform(dpr,0,0,dpr,0,0);
+  }
+
+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);
+  const neighbours=adjacency.get(id)||[];
+  // 不再"点亮整个扇面"：只随机挑 2~4 条邻居。
+  // 一次把几十条边同时点亮，看上去就是全图一起闪。
+  const count=Math.min(neighbours.length,2+Math.floor(Math.random()*3));
+  const picked=new Set();
+  let guard=0;
+  while (picked.size<count && neighbours.length && guard++<200) {
+    picked.add(neighbours[Math.floor(Math.random()*neighbours.length)]);
+  }
+  for (const other of picked) {
+    // 邻居亮度也压低：原来 0.65 会让整片区域同时亮起来
+    firing.set(other,Math.max(0.26,firing.get(other)||0));
+    pulses.push({from:id,to:other,born:now,life:700+Math.random()*2400});
+  }
+}
+
+  function select(x,y) {
+  let best=null,bestScore=Infinity;
+  for (const star of nodes) {
+    if (!star._screen) continue;
+    const value=Math.hypot(star._screen.x-x,star._screen.y-y);
+    const tolerance=Math.max(14,star._screen.r*1.15);
+    if (value>tolerance) continue;
+    const score=value-star._screen.r*0.22;
+    if (score<bestScore) {bestScore=score;best=star;}
+  }
+  if (!best) return;
+  fire(best.id,performance.now());
+    for (const callback of selections) callback(byId.get(best.id));
+  }
+
+  function onPointerDown(event) {
+    resumeAt=Infinity;
+    autoSpin=false; drag={x:event.clientX,y:event.clientY,moved:0,pointerId:event.pointerId};
+    canvas.setPointerCapture(event.pointerId);
+  }
+  function onPointerMove(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));
+  }
+  function releaseDrag() {
+    if (drag && running) resumeAt=performance.now()+2000;
+    if (drag && canvas.hasPointerCapture(drag.pointerId)) canvas.releasePointerCapture(drag.pointerId);
+    drag=null;
+  }
+  function onPointerUp(event) {
+    const clicked = drag && drag.moved<6;
+    releaseDrag();
+    if (clicked) {
+      const bounds = canvas.getBoundingClientRect();
+      select(event.clientX-bounds.left,event.clientY-bounds.top);
+    }
+  }
+  function onWheel(event) {
+    event.preventDefault();
+    zoom=Math.max(0.3,Math.min(4.5,zoom*(event.deltaY>0?0.92:1.08)));
+  }
+
+function frame(now) {
+  const delta=Math.min(50,now-lastTime||16.7); lastTime=now;
+  if (!autoSpin && !drag && now>=resumeAt) autoSpin=true;
+  if (autoSpin) rotY+=0.0011*spinSpeed*3*delta/16.7;
+  if (now>nextFire) {
+    // 心跳节奏别太机械：间隔随机，偶尔连发两个，偶尔安静久一点
+    const burst=Math.random()<0.22 ? 2 : 1;
+    for (let i=0;i<burst && hubs.length;i++) {
+      fire(hubs[Math.floor(Math.random()*hubs.length)].id,now);
+    }
+    nextFire=now+1400+Math.random()*3200;
+  }
+  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*.00007+index)*30,width*.7,y-Math.cos(now*.00006+index)*30,width,y);ctx.stroke();
+  }
+  const points=[];
+  for (const star of nodes) {
+    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)=>left.star.isCore?1:right.star.isCore?-1:right.p.depth-left.p.depth);
+  const screen=new Map(points.map(point=>[point.star.id,point]));
+  ctx.globalCompositeOperation='lighter';
+  for (let linkIndex=0;linkIndex<links.length;linkIndex++) {
+    const [left,right]=links[linkIndex];
+    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 twinkle=linkTwinkle[linkIndex];
+    const breathe=twinkle ? (0.5+0.5*Math.sin(now*twinkle.freq+twinkle.phase))*twinkle.amp : 0;
+    // 度数补偿：枢纽节点周围几十条线会糊成一块光斑，
+    // 按两端度数把这类线整体压暗，让"一条线"和"一堆线"的观感接近。
+    const degSum=(first.star.degree||0)+(second.star.degree||0);
+    const damp=1/(1+0.07*Math.max(0,degSum-6));
+    const alpha=Math.min(.85,(.1*Math.min(first.star.retention,second.star.retention)+.12*act+breathe)*damp);
+    if (alpha<.01) continue;
+    // 端点沿法线错开，多条线进入同一节点时散成扇形
+    const dx=second.p.x-first.p.x, dy=second.p.y-first.p.y;
+    const len=Math.hypot(dx,dy)||1;
+    const nx=-dy/len, ny=dx/len;
+    const r1=Math.max(2,first.star.radius*first.p.scale*.55);
+    const r2=Math.max(2,second.star.radius*second.p.scale*.55);
+    const sx=first.p.x+nx*r1*0.9*(twinkle?twinkle.jitterStart:0);
+    const sy=first.p.y+ny*r1*0.9*(twinkle?twinkle.jitterStart:0);
+    const ex=second.p.x+nx*r2*0.9*(twinkle?twinkle.jitterEnd:0);
+    const ey=second.p.y+ny*r2*0.9*(twinkle?twinkle.jitterEnd:0);
+    // 弯曲方向和弯度都按连线各自的哈希来，避免所有线朝同一侧弯成漩涡
+    const bow=twinkle?twinkle.bow:0.18;
+    const mx=(sx+ex)/2+nx*len*bow*0.5;
+    const my=(sy+ey)/2+ny*len*bow*0.5;
+    ctx.strokeStyle='rgba(110,190,255,'+alpha+')';ctx.lineWidth=.7+act*1.6+breathe*1.4;
+    ctx.beginPath();ctx.moveTo(sx,sy);ctx.quadraticCurveTo(mx,my,ex,ey);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);
+    // 每颗星自己的呼吸频率和相位：从 id 哈希来，避免全图同一个节拍
+    if (star._pulse===undefined) {
+      const h=hashString(star.id);
+      star._pulse={freq:0.00018+(h%1000)/1000*0.00045,phase:(Math.floor(h/1000)%6283)/1000,amp:0.035+(Math.floor(h/7e6)%100)/100*0.045};
+    }
+    const pulse=star._pulse;
+    const breathe=Math.sin(now*pulse.freq+pulse.phase)*pulse.amp;
+    const radius=Math.max(2,star.radius*p.scale*.55)*(1+breathe)*(1+act*.5);
+    const rgb=star._rgb.join(',');
+    if (star.isCore) {
+      const halo=ctx.createRadialGradient(p.x,p.y,radius*.75,p.x,p.y,radius*2.2);
+      halo.addColorStop(0,'rgba('+rgb+',0.12)');
+      halo.addColorStop(.65,'rgba('+rgb+',0.04)');
+      halo.addColorStop(1,'rgba('+rgb+',0)');
+      ctx.fillStyle=halo;ctx.beginPath();ctx.arc(p.x,p.y,radius*2.2,0,Math.PI*2);ctx.fill();
+      ctx.strokeStyle='rgba('+rgb+',0.38)';ctx.lineWidth=.7;ctx.setLineDash([3,5]);ctx.lineDashOffset=-now*.008;
+      ctx.beginPath();ctx.arc(p.x,p.y,radius*1.6,0,Math.PI*2);ctx.stroke();
+      ctx.setLineDash([]);ctx.lineDashOffset=0;
+    }
+    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);
+}
+  function start() {
+    if (running || destroyed) return;
+    running=true; lastTime=0; nextFire=0; autoSpin=true; resumeAt=0;
+    const currentGeneration = ++generation;
+    canvas.addEventListener('pointerdown',onPointerDown);
+    canvas.addEventListener('pointermove',onPointerMove);
+    canvas.addEventListener('pointerup',onPointerUp);
+    canvas.addEventListener('pointercancel',releaseDrag);
+    canvas.addEventListener('wheel',onWheel,{passive:false});
+    window.addEventListener('resize',resize);
+    if (window.ResizeObserver) {
+      observer = new window.ResizeObserver(resize);
+      observer.observe(canvas);
+    }
+    resize();
+    function tick(now) {
+      if (!running || destroyed || currentGeneration !== generation) return;
+      rafId=null;
+      frame(now);
+      if (running && !destroyed && currentGeneration === generation) rafId=window.requestAnimationFrame(tick);
+    }
+    rafId=window.requestAnimationFrame(tick);
+  }
+
+  function stop() {
+    running=false; generation++;
+    if (rafId !== null) window.cancelAnimationFrame(rafId);
+    rafId=null;
+    observer?.disconnect(); observer=null;
+    canvas.removeEventListener('pointerdown',onPointerDown);
+    canvas.removeEventListener('pointermove',onPointerMove);
+    canvas.removeEventListener('pointerup',onPointerUp);
+    canvas.removeEventListener('pointercancel',releaseDrag);
+    canvas.removeEventListener('wheel',onWheel);
+    window.removeEventListener('resize',resize);
+    releaseDrag();
+    pulses.length=0; firing.clear(); lastTime=0; nextFire=0;
+  }
+
+  function destroy() {
+    if (destroyed) return;
+    stop(); destroyed=true;
+    selections.clear(); byId.clear(); adjacency.clear(); sprites.clear();
+    nodes=[]; links=[]; hubs=[];
+  }
+
+  setData(data);
+  return {
+    start, stop, resize, setData, destroy,
+    fireNeuron(id) { if (!destroyed && byId.has(id)) fire(id,performance.now()); },
+    onSelect(callback) {
+      if (!destroyed) selections.add(callback);
+      return () => selections.delete(callback);
+    },
+  };
+}
+

package/lib/render/layout.mjs

@@ -1,6 +1,49 @@
 const SEED = 20261030;
 
 export function layoutMemories(nodes) {
+  if (!nodes.some(node => node.isCore)) return layoutBrain(nodes);
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  const inner = node => ['印象', '知识', '事件'].includes(node.kind);
+  const memories = nodes.filter(node => !node.isCore);
+  const shells = [memories.filter(inner), memories.filter(node => !inner(node))];
+  const placed = new Map();
+  function jitter(index) {
+    let hash = (index + 1) ^ SEED;
+    hash = Math.imul(hash ^ (hash >>> 16), 0x45d9f3b);
+    hash = Math.imul(hash ^ (hash >>> 16), 0x45d9f3b);
+    return ((hash ^ (hash >>> 16)) >>> 0) / 4294967295 * 2 - 1;
+  }
+  shells.forEach((shell, layer) => {
+    shell.forEach((node, index) => {
+      const vertical = 1 - index / Math.max(1, shell.length - 1) * 2;
+      const radial = Math.sqrt(Math.max(0, 1 - vertical * vertical));
+      const angle = golden * (index + layer * 0.5);
+      const event = node.kind === '事件';
+      // 壳做厚，而不是贴在球面上：薄壳会把 236 个节点挤成一团。
+      // 内层 26~58（厚度 32），外层 70~108，节点沿半径方向均匀铺开，看起来才有立体感。
+      const layerMin = layer === 0 ? 26 : 70;
+      const layerMax = layer === 0 ? 58 : 108;
+      const age = layer === 1 ? Math.min(1, Math.max(0, node.ageDays / 30)) * 12 : 0;
+      // jitter 归一到 0~1，在 [layerMin, layerMax] 之间铺开
+      const spread = 0.5 + 0.5 * jitter(index + layer * memories.length);
+      // 情绪重的事件往内层靠一点，视觉上更"贴身"
+      const pull = event && node.majorEmotion ? 7 * spread : 0;
+      const distance = layerMin + (layerMax - layerMin) * spread - pull + age;
+      const baseRadius = node.majorEmotion ? 3.2 : layer === 0
+        ? (node.heat === 1 ? 2.4 : node.heat === 2 ? 1.8 : 1.3)
+        : (node.heat === 1 ? 2.1 : node.heat === 2 ? 1.5 : 1.0);
+      placed.set(node, { ...node, pos: {
+        x: Math.cos(angle) * radial * distance,
+        y: vertical * distance * 0.92,
+        z: Math.sin(angle) * radial * distance,
+      }, radius: Math.min(layer === 0 ? 4.2 : 3.2, baseRadius + Math.min(1.1, Math.sqrt(node.degree) * 0.15)) });
+    });
+  });
+  relax([...placed.values()], { iterations: 80, gap: 1.9, strength: 0.5 });
+  return nodes.map(node => node.isCore ? { ...node, pos: { x: 0, y: 0, z: 0 }, radius: 8 } : placed.get(node));
+}
+
+function layoutBrain(nodes) {
   let seed = SEED;
   const random = () => ((seed = (seed * 16807) % 2147483647) - 1) / 2147483646;
   function brainPoint(radiusScale) {