dsh-memory-engine 0.7.0-beta.2b → 0.7.0-beta.6b

package/lib/index.js

@@ -2,6 +2,8 @@ import { MemoryStore } from './store.js';
 import { chars, titleOf } from './decay.js';
 import { generateMap, mapReport, openMap } from './map.js';
 import { registerMemoryRoutes } from './routes.js';
+import { createAutoMemory } from './auto-memory.js';
+import { createAutoImport } from './auto-import.js';
 
 export const name = 'memory-engine';
 export const inject = ['tools', 'webServer'];
@@ -53,14 +55,28 @@ export function createTools(defineTool, store = new MemoryStore(), { map = gener
       }, output,
       async execute(args) {
         const hits = store.recall(args);
-        if (!hits.length) return `没有找到跟「${args.q}」相关的记忆。`;
+        if (!hits.length) return `【没有找到】「${args.q}」在记忆库里没有相关内容。`;
+        const quote = words => words.map(word => `「${word}」`).join('');
         let index = 0;
-        return ['direct', 'spread'].map(via => {
+        const describe = hit => `${++index}. [${hit.kind}] ${titleOf(hit)}（留存 ${hit.retention.toFixed(2)}；id=${hit.id}）`;
+        const sections = [];
+        for (const via of ['direct', 'partial']) {
           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');
+          if (!group.length) continue;
+          const terms = group[0].terms;
+          const matched = terms.filter(term => group.some(hit => hit.matched.includes(term)));
+          const missed = terms.filter(term => !matched.includes(term));
+          const label = via === 'direct' ? '直接命中' : '部分命中';
+          const summary = `【${label} ${group.length} 条】` + (via === 'partial' ? '（覆盖不足 50%，不是直接命中）' : '')
+            + `命中${quote(matched)}` + (missed.length ? `；未命中${quote(missed)}` : '；全部查询词均命中');
+          sections.push([summary, ...group.map(hit => `${describe(hit)}\n`
+            + `   覆盖 ${hit.matched.length}/${hit.terms.length}；命中${quote(hit.matched)}`
+            + (hit.missed.length ? `；未命中${quote(hit.missed)}` : '') + `\n   ${hit.snippet}`)].join('\n\n'));
+        }
+        const spread = hits.filter(hit => hit.via === 'spread');
+        if (spread.length) sections.push(['【联想到的（不是直接命中）】', ...spread.map(hit => `${describe(hit)}\n`
+          + `   从「${hit.from.title}」（id=${hit.from.id}）联想：完整标题「${hit.from.term}」出现在关联正文中。\n   ${hit.snippet}`)].join('\n\n'));
+        return sections.join('\n\n');
       },
     }),
     defineTool({
@@ -188,6 +204,12 @@ export function apply(ctx) {
         } catch (error) {
           warn(ctx, `图谱路由注册失败，记忆工具仍可用：${error.message}`);
         }
+        for (const create of [createAutoMemory, createAutoImport]) {
+          try {
+            const automation = create({ ctx, store, warn: message => warn(ctx, message) });
+            disposers.push(() => automation.dispose());
+          } catch (error) { warn(ctx, `自动任务初始化失败，记忆工具仍可用：${error.message}`); }
+        }
         const timer = setTimeout(() => {
           try { if (store.read().length > 0) generateMap(store); }
           catch (error) { warn(ctx, `启动时图谱生成失败：${error.message}`); }

package/lib/map.js

@@ -4,16 +4,23 @@ 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) {
+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 nodes = layoutMemories(scored.nodes);
+  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 } };
 }
 

package/lib/noise.js

@@ -0,0 +1,20 @@
+export const DEFAULT_NOISE_PATTERNS = Object.freeze([
+  '重复唤醒', '已经回过', '回过了', '先不重复', '继续潜水', '潜水状态',
+  '标成已读', '已读水位', '先不发送', '没再发', '等他说下一句',
+  '看一眼情况', '没有新消息', '这轮是', '我先不', '对话停在这里',
+  '对话就停在这', '等有人 @', '再回来就是', '未读 0',
+]);
+
+const REPORT_PREFIX = /^\s*(已回|已回复|已发送|已处理|已确认|已读|已标记|回过了|发过了)\s*[:：]/u;
+
+export function isNoise(text, extra = []) {
+  if (typeof text !== 'string') return false;
+  if (REPORT_PREFIX.test(Array.from(text).slice(0, 12).join(''))) return true;
+  const features = text.replace(/(?:他|她|对方|朋友|同事)(?:说|表示|告诉我)[\s“「『"']*(?:已经回过|回过了)/gu, '');
+  const patterns = new Set([...DEFAULT_NOISE_PATTERNS, ...extra].filter(pattern => typeof pattern === 'string' && pattern.length > 0));
+  let hits = 0;
+  for (const pattern of patterns) {
+    if (features.includes(pattern) && ++hits >= 2) return true;
+  }
+  return hits === 1 && Array.from(text).length < 150;
+}

package/lib/recall.js

@@ -1,25 +1,56 @@
 import { chars, retention, titleOf } from './decay.js';
 
+export function queryTerms(query) {
+  return [...new Set(query.trim().toLocaleLowerCase().split(/[\s\p{P}\p{S}]+/u)
+    .filter(term => Array.from(term).length >= 2))];
+}
+
 export function relevance(memory, query) {
-  const q = query.trim().toLocaleLowerCase();
-  if (!q) return 0;
+  const normalized = query.trim().toLocaleLowerCase();
   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;
+  const terms = queryTerms(query);
+  const matched = terms.filter(term => title.includes(term) || text.includes(term));
+  const missed = terms.filter(term => !matched.includes(term));
+  let score = 0;
+  for (const term of terms) {
+    if (title.includes(term)) score += 3;
+    if (text.includes(term)) score += 2;
+    if (title.startsWith(term)) score += 2;
+  }
+  if (normalized && title.includes(normalized)) score += 4;
+  if (normalized && text.includes(normalized)) score += 2;
+  return Object.defineProperty({ score, coverage: terms.length ? matched.length / terms.length : 0, terms, matched, missed },
+    Symbol.toPrimitive, { value: () => score });
+}
+
+function snippet(text, terms) {
+  const characters = Array.from(text);
+  const positions = [];
   for (const term of terms) {
-    if (title.includes(term)) rel += 3;
-    if (text.includes(term)) rel += 2;
-    if (title.startsWith(term)) rel += 2;
+    const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    for (const match of text.matchAll(new RegExp(escaped, 'giu'))) {
+      const start = Array.from(text.slice(0, match.index)).length;
+      positions.push({ start, end: start + Array.from(match[0]).length });
+    }
+  }
+  positions.sort((first, second) => first.start - second.start);
+  let selected = chars(text, 120), bestCoverage = 0;
+  for (const position of positions) {
+    const start = Math.max(0, position.start - 45);
+    const end = Math.min(characters.length, position.end + 45);
+    const context = characters.slice(start, end).join('');
+    const coverage = terms.filter(term => context.toLocaleLowerCase().includes(term)).length;
+    if (coverage <= bestCoverage) continue;
+    bestCoverage = coverage;
+    selected = (start > 0 ? '…' : '') + context + (end < characters.length ? '…' : '');
   }
-  if (title.includes(q)) rel += 4;
-  if (text.includes(q)) rel += 2;
-  return rel;
+  return selected;
 }
 
-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));
+function related(first, second) {
+  return (Array.from(first.title).length >= 4 && second.text.includes(first.title))
+    || (Array.from(second.title).length >= 4 && first.text.includes(second.title));
 }
 
 export function recall(memories, { q, limit = 8, hops = 1, kind }, now = Date.now()) {
@@ -28,32 +59,40 @@ export function recall(memories, { q, limit = 8, hops = 1, kind }, now = Date.no
   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 }));
+      title: titleOf(memory).toLocaleLowerCase(), text: memory.text.toLocaleLowerCase(), ...relevance(memory, q) }));
   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]));
+  const matches = sorted(pool.filter(row => row.matched.length > 0)
+    .map(row => ({ ...row, via: row.coverage >= 0.5 ? 'direct' : 'partial', score: row.score * (0.35 + 0.65 * row.retention) })));
+  const direct = matches.filter(row => row.via === 'direct').slice(0, limit);
+  const partial = matches.filter(row => row.via === 'partial').slice(0, limit - direct.length);
+  if (!direct.length && !partial.length) return [];
+  const spreadLimit = Math.min(limit - direct.length - partial.length, Math.floor(direct.length / 2));
+  const matchedIds = new Set(matches.map(row => row.memory.id));
+  const threshold = direct.length ? direct[0].score * 0.35 : Infinity;
+  const best = new Map();
   let frontier = direct;
-  for (let hop = 0; hop < hops; hop++) {
+  for (let hop = 0; hop < hops && spreadLimit > 0; 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;
+      const score = source.score * 0.45;
+      if (score < threshold) continue;
       for (const neighbor of pool) {
-        if (neighbor.memory.id === source.memory.id || neighbor.retention <= 0.4
+        if (matchedIds.has(neighbor.memory.id) || 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' };
+        const sharedTitle = Array.from(source.title).length >= 4 && neighbor.text.includes(source.title)
+          ? titleOf(source.memory) : titleOf(neighbor.memory);
+        const hit = { ...neighbor, score, via: 'spread', from: { id: source.memory.id, title: titleOf(source.memory), term: sharedTitle } };
         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 }));
+  return [...direct, ...partial, ...sorted([...best.values()]).slice(0, spreadLimit)]
+    .map(({ memory, score, retention: value, via, coverage, terms, matched, missed, from }) => ({
+      ...memory, score, retention: value, via, coverage, terms, matched, missed,
+      snippet: snippet(memory.text, via === 'spread' ? [from.term.toLocaleLowerCase()] : matched),
+      ...(from ? { from } : {}),
+    }));
 }

package/lib/render/canvas.js

@@ -6,14 +6,18 @@ export function createRenderer(canvas, data, options = {}) {
   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 = [];
+  let nodes = [], links = [], hubs = [], linkTwinkle = [], visibleLinks = [];
   const byId = new Map(), adjacency = new Map(), sprites = new Map();
   const pulses = [], firing = new Map(), selections = new Set();
+  // 默认不画连线（数量太大会卡），只画选中光点周围的线
+  let selectedId=null, selectedNeighbours=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 drag=null,nextFire=0,lastTime=0,rafId=null,running=false,destroyed=false,generation=0,observer=null;
+  let spinSpeed=data.spinSpeed??0.35,resumeAt=0;
+  const frameInterval=Number.isFinite(options.frameInterval)?Math.max(0,options.frameInterval):0;
+  let drag=null,nextFire=0,lastTime=0,lastDrawAt=0,rafId=null,running=false,destroyed=false,generation=0,observer=null;
 
 function glowSprite(rgb) {
   const off = document.createElement('canvas');
@@ -27,11 +31,26 @@ function glowSprite(rgb) {
   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();
+    selectedId=typeof options.selectedId==='string'?options.selectedId:null;
+    selectedNeighbours=new Set(selectedId?(adjacency.get(selectedId)||[]):[]);
     seed = 987654321; nextFire = 0;
     for (const node of nextData.nodes) byId.set(node.id, node);
     for (const node of nodes) adjacency.set(node.id, []);
@@ -39,6 +58,41 @@ function glowSprite(rgb) {
       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,
+      };
+    });
+    // 连线数量会随记忆增长爆炸（332 条时 383 根，479 条时 1738 根）。
+    // 每帧全画会卡，所以按"两端留存"排序，最多画 LINK_DRAW_CAP 根最亮的，
+    // 其余的不进这一帧（数据没丢，只是不画，缩放/点击仍按全量算）。
+    const LINK_DRAW_CAP = 1200;
+    if (links.length <= LINK_DRAW_CAP) {
+      visibleLinks = links.map((_, index) => index);
+    } else {
+      const byIdLocal = new Map(nodes.map(node => [node.id, node]));
+      const strength = index => {
+        const [left, right] = links[index];
+        const a = byIdLocal.get(left), b = byIdLocal.get(right);
+        return Math.min(a?.retention ?? 0, b?.retention ?? 0) + Math.min(a?.degree ?? 0, b?.degree ?? 0) * 0.002;
+      };
+      visibleLinks = links.map((_, index) => index)
+        .sort((x, y) => strength(y) - strength(x))
+        .slice(0, LINK_DRAW_CAP);
+    }
 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));
@@ -74,9 +128,21 @@ function project(pos) {
 }
 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});
+  const neighbours=adjacency.get(id)||[];
+  // 选中某个光点时，把它的关联线都点亮几条脉冲（最多 24 条，避免又糊成一片）；
+  // 未选中时的随机心跳只挑 2~4 条，避免整片区域同时亮。
+  const selected = id===selectedId;
+  const limit = selected ? 24 : 2+Math.floor(Math.random()*3);
+  const count=Math.min(neighbours.length,limit);
+  const picked=new Set();
+  let guard=0;
+  while (picked.size<count && neighbours.length && guard++<400) {
+    picked.add(neighbours[Math.floor(Math.random()*neighbours.length)]);
+  }
+  for (const other of picked) {
+    // 邻居亮度也压低：原来 0.65 会让整片区域同时亮起来
+    firing.set(other,Math.max(selected?0.4:0.26,firing.get(other)||0));
+    pulses.push({from:id,to:other,born:now,life:700+Math.random()*2400});
   }
 }
 
@@ -91,11 +157,14 @@ function fire(id,now) {
     if (score<bestScore) {bestScore=score;best=star;}
   }
   if (!best) return;
+  selectedId = best.id;
+  selectedNeighbours = new Set(adjacency.get(best.id) || []);
   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);
   }
@@ -106,6 +175,7 @@ function fire(id,now) {
     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;
   }
@@ -124,13 +194,27 @@ function fire(id,now) {
 
 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); }
+  if (!autoSpin && !drag && now>=resumeAt) autoSpin=true;
+  if (autoSpin) rotY+=0.0011*spinSpeed*3*delta/16.7;
+  if (now>nextFire) {
+    // 默认不画连线，所以也不撒"沿线的脉冲"——否则会出现飘来飘去的小点，找不到来源。
+    // 选中光点后，脉冲只在它的关联线上跑。
+    if (selectedId) {
+      fire(selectedId,now);
+    } else {
+      // 没选中时只让枢纽光点自己亮一下，不动线
+      if (hubs.length) {
+        const hub=hubs[Math.floor(Math.random()*hubs.length)];
+        firing.set(hub.id,1);
+      }
+    }
+    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*.0003+index)*30,width*.7,y-Math.cos(now*.00025+index)*30,width,y);ctx.stroke();
+    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) {
@@ -138,19 +222,39 @@ function frame(now) {
     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);
+  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 (const [left,right] of 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();
+  // 连线只在"选中某个光点"时画，且只画和它相连的那些。
+  // 全量 1738 根每帧画会卡；默认干干净净，点谁看谁的关联。
+  const linkPaths=[];
+  if (selectedId) {
+    for (const [left,right] of links) {
+      if (left!==selectedId && right!==selectedId) continue;
+      const first=screen.get(left),second=screen.get(right);
+      if (!first||!second) continue;
+      const target = left===selectedId ? second : first;
+      const ret = Math.min(first.star.retention, second.star.retention);
+      const alpha = Math.min(.9, .22 + ret*.35);
+      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 bow = (target===second ? 1 : -1) * .16;
+      const mx=(first.p.x+second.p.x)/2+nx*len*bow*.5;
+      const my=(first.p.y+second.p.y)/2+ny*len*bow*.5;
+      linkPaths.push([first.p.x,first.p.y,mx,my,second.p.x,second.p.y,alpha]);
+    }
+  }
+  if (linkPaths.length) {
+    ctx.strokeStyle='rgba(110,190,255,0.30)';
+    ctx.lineWidth=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='rgba(160,220,255,0.22)';
+    ctx.lineWidth=2;
+    ctx.stroke();
   }
   for (let index=pulses.length-1;index>=0;index--) {
     const pulse=pulses[index],fraction=(now-pulse.born)/pulse.life;
@@ -166,8 +270,25 @@ function frame(now) {
   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);
+    // 每颗星自己的呼吸频率和相位：从 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);
@@ -202,7 +323,7 @@ function frame(now) {
 }
   function start() {
     if (running || destroyed) return;
-    running=true; lastTime=0; nextFire=0;
+    running=true; lastTime=0; nextFire=0; autoSpin=true; resumeAt=0;
     const currentGeneration = ++generation;
     canvas.addEventListener('pointerdown',onPointerDown);
     canvas.addEventListener('pointermove',onPointerMove);
@@ -218,6 +339,13 @@ function frame(now) {
     function tick(now) {
       if (!running || destroyed || currentGeneration !== generation) return;
       rafId=null;
+      // 帧率上限靠 options.frameInterval 控制（默认 0 = 不限）。
+      // 界面里按 40fps 传；测试里不传，保持逐帧确定性。
+      if (frameInterval > 0 && now - lastDrawAt < frameInterval) {
+        rafId=window.requestAnimationFrame(tick);
+        return;
+      }
+      lastDrawAt = now;
       frame(now);
       if (running && !destroyed && currentGeneration === generation) rafId=window.requestAnimationFrame(tick);
     }

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) {

package/lib/render/render.mjs

@@ -25,6 +25,7 @@ export function renderHtml(data, title = '记忆神经网络') {
   .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}
+  .panel.core .text{max-height:52vh;overflow:auto}.copy{margin-top:12px;padding:7px 12px;border:1px solid #6999b8;border-radius:8px;background:#102236;color:#e2f4ff;font:inherit;cursor:pointer}
   .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}
@@ -36,9 +37,9 @@ export function renderHtml(data, title = '记忆神经网络') {
 <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="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><button class="copy" id="copy" hidden>复制全文</button></section>
 <section class="review"><h2>复习清单 · 留存最低的记忆</h2><div id="reviewList"></div></section>
-<div class="tip">拖拽旋转 · 滚轮缩放 · 点击查看记忆</div>
+<div class="tip">拖拽旋转 · 滚轮缩放 · 点击光点看关联</div>
 <script>
 const DATA = ${embedded};
 const canvas = document.getElementById('map');
@@ -56,10 +57,30 @@ for (const [index,item] of DATA.review.entries()) {
 }
 renderer.onSelect(node => {
   document.getElementById('panel').style.display='block';
+  document.getElementById('panel').className=node.isCore?'panel core':'panel';
   document.getElementById('kind').textContent=node.kind;
   document.getElementById('title').textContent=node.title;
+  document.getElementById('meta').hidden=!!node.isCore;
   document.getElementById('meta').textContent='重要度 '+node.heat+' · 留存 '+node.retention.toFixed(2)+' · 连接数 '+node.degree+(node.emotion.length?' · '+node.emotion.map(item=>item.tag).join('/'):'');
-  document.getElementById('body').textContent=node.text;
+  const text=node.isCore?Array.from(node.text).slice(0,4000).join(''):node.text;
+  document.getElementById('body').textContent=text;
+  document.getElementById('body').scrollTop=0;
+  const copy=document.getElementById('copy');
+  copy.hidden=!node.isCore; copy.textContent='复制全文';
+  const copyBody=async () => {
+    function fallback() {
+      const area=document.createElement('textarea');
+      area.value=text; area.style.cssText='position:fixed;left:-9999px'; document.body.append(area); area.select();
+      try { if (!document.execCommand('copy')) throw new Error('复制失败'); } finally { area.remove(); }
+    }
+    try {
+      if (navigator.clipboard?.writeText) {
+        try { await navigator.clipboard.writeText(text); } catch { fallback(); }
+      } else fallback();
+      if (copy.onclick===copyBody) copy.textContent='已复制 ✓';
+    } catch { if (copy.onclick===copyBody) copy.textContent='复制失败，请重试'; }
+  };
+  copy.onclick=copyBody;
 });
 renderer.start();
 </script>