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

package/lib/render/canvas.js

@@ -6,13 +6,14 @@ 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 = [];
   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) {
@@ -27,8 +28,21 @@ 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();
@@ -39,6 +53,24 @@ 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,
+      };
+    });
 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 +106,19 @@ 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)||[];
+  // 不再"点亮整个扇面"：只随机挑 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});
   }
 }
 
@@ -96,6 +138,7 @@ function fire(id,now) {
   }
 
   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 +149,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 +168,21 @@ 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) {
+    // 心跳节奏别太机械：间隔随机，偶尔连发两个，偶尔安静久一点
+    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*.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 +190,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) {
+  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 alpha=Math.min(.85,.1*Math.min(first.star.retention,second.star.retention)+.35*act);
+    // 连线自己也会呼吸：每条线有独立相位和频率，不再"齐刷刷"地一起闪。
+    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 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();
+    // 端点沿法线错开，多条线进入同一节点时散成扇形
+    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;
@@ -166,8 +238,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 +291,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);

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,7 +37,7 @@ 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>
 <script>
@@ -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>

package/lib/routes.js

@@ -3,21 +3,87 @@ import { computeMapData } from './map.js';
 import { renderHtml } from './render/render.mjs';
 import { ONBOARD_PROMPT, ONBOARD_STEPS } from './onboard.js';
 import { readUiConfig } from './config.js';
+import { chars, retention, titleOf } from './decay.js';
+import { scoreMemories } from './render/score.mjs';
 
 const base = '/memory-engine';
-const paths = new Set([base, `${base}/`, `${base}/api/map`, `${base}/api/stats`, `${base}/api/onboard`, `${base}/api/config`]);
+const paths = new Set([base, `${base}/`, `${base}/api/map`, `${base}/api/stats`, `${base}/api/onboard`, `${base}/api/config`,
+  `${base}/api/list`, `${base}/api/export`, `${base}/api/clear`]);
 const allowedMethods = new Set(['GET', 'POST', 'PUT', 'DELETE']);
 const escapeBridge = '<script>window.addEventListener("keydown",function(event){if(event.key==="Escape")parent.postMessage({type:"dsh-memory-engine-close"},"*")});</script>';
 
+function readBody(request) {
+  return new Promise((resolve, reject) => {
+    let bytes = 0;
+    let chunks = [];
+    const finish = (error, value) => {
+      request.removeListener('data', onData);
+      request.removeListener('end', onEnd);
+      request.removeListener('error', onError);
+      request.removeListener('aborted', onAborted);
+      chunks = [];
+      if (error) reject(error); else resolve(value);
+    };
+    const onError = error => finish(error);
+    const onAborted = () => finish(Object.assign(new Error('请求已中断'), { status: 400 }));
+    const onData = chunk => {
+      bytes += chunk.length;
+      if (bytes > 1024 * 1024) {
+        finish(Object.assign(new Error('请求体不能超过 1MB'), { status: 413 }));
+        request.resume();
+      } else chunks.push(chunk);
+    };
+    const onEnd = () => {
+      let value;
+      try { value = JSON.parse(Buffer.concat(chunks).toString('utf8')); }
+      catch { return finish(Object.assign(new Error('请求体必须是有效 JSON'), { status: 400 })); }
+      if (!value || typeof value !== 'object' || Array.isArray(value)) return finish(Object.assign(new Error('请求体必须是 JSON 对象'), { status: 400 }));
+      finish(null, value);
+    };
+    request.on('data', onData);
+    request.on('end', onEnd);
+    request.on('error', onError);
+    request.on('aborted', onAborted);
+  });
+}
+
+function describeMemories(rows, now) {
+  const items = rows.map(row => ({ ...row, title: titleOf(row) }));
+  const degrees = new Map(scoreMemories(items, now).nodes.map(node => [node.id, node.degree]));
+  return items.map(row => ({ ...row, retention: retention(row, now), degree: degrees.get(row.id) }));
+}
+
+function listMemories(store, query) {
+  const sort = query.get('sort') || 'recent';
+  const invalid = message => { throw Object.assign(new Error(message), { status: 400 }); };
+  if (!['recent', 'oldest', 'fading', 'degree'].includes(sort)) invalid('sort 必须是 recent、oldest、fading 或 degree');
+  const limit = Number(query.get('limit') ?? 50);
+  const offset = Number(query.get('offset') ?? 0);
+  if (!Number.isSafeInteger(limit) || limit < 1) invalid('limit 必须是正整数');
+  if (!Number.isSafeInteger(offset) || offset < 0) invalid('offset 必须是非负整数');
+  const rows = store.read();
+  const search = (query.get('q') || '').toLowerCase();
+  const kind = query.get('kind') || '';
+  const items = describeMemories(rows, store.now()).filter(row => (!kind || row.kind === kind)
+    && (!search || row.text.toLowerCase().includes(search) || row.title.toLowerCase().includes(search)));
+  const ordering = { recent: (left, right) => right.ts - left.ts, oldest: (left, right) => left.ts - right.ts,
+    fading: (left, right) => left.retention - right.retention, degree: (left, right) => right.degree - left.degree };
+  items.sort(ordering[sort]);
+  const size = Math.min(200, limit);
+  return { total: items.length, allTotal: rows.length, limit: size, offset,
+    items: items.slice(offset, offset + size).map(row => ({ ...row, preview: chars(row.text, 60) + (Array.from(row.text).length > 60 ? '…' : '') })) };
+}
+
 export function createMemoryHandler({ store, warn = () => {} }) {
   return async (request, response) => {
+    let methods = ['GET'];
     const reply = (status, payload, html = false) => {
       response.writeHead(status, {
         'Content-Type': html ? 'text/html; charset=utf-8' : 'application/json; charset=utf-8',
         'Cache-Control': 'no-store',
         'X-Content-Type-Options': 'nosniff',
         'Referrer-Policy': 'no-referrer',
-        ...(status === 405 ? { Allow: 'GET' } : {}),
+        ...(status === 405 ? { Allow: methods.join(', ') } : {}),
         ...(html ? { 'Content-Security-Policy': "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'none'; frame-ancestors 'self'" } : {}),
       });
       response.end(html ? payload : JSON.stringify(payload));
@@ -30,20 +96,39 @@ export function createMemoryHandler({ store, warn = () => {} }) {
       let pathname;
       try { pathname = decodeURIComponent(rawPath); }
       catch { return fail(404, '找不到这个记忆接口'); }
-      if (pathname.includes('..') || pathname.includes('\\') || !paths.has(pathname)) return fail(404, '找不到这个记忆接口');
-      if (!allowedMethods.has(request.method) || request.method !== 'GET') return fail(405, '此接口仅支持 GET');
+      const item = /^\/memory-engine\/api\/item\/([^/%\\]+)$/u.exec(pathname);
+      if (pathname.includes('..') || pathname.includes('\\') || (!paths.has(pathname) && !item)) return fail(404, '找不到这个记忆接口');
+      methods = item ? ['GET', 'PUT', 'DELETE'] : pathname === `${base}/api/clear` ? ['POST'] : ['GET'];
+      if (!allowedMethods.has(request.method) || !methods.includes(request.method)) return fail(405, `此接口仅支持 ${methods.join('、')}`);
       if (Number(request.headers['content-length']) > 1024 * 1024) return fail(413, '请求体不能超过 1MB');
-      if (request.headers['transfer-encoding'] || Number(request.headers['content-length']) > 0) return fail(400, '此只读接口不接受请求体');
-      if (pathname === `${base}/api/map`) return reply(200, { ok: true, data: computeMapData(store) });
+      if (request.method === 'PUT' || request.method === 'POST') {
+        if (!/^application\/json(?:\s*;|$)/i.test(request.headers['content-type'] ?? '')) return fail(400, '请求体必须使用 application/json');
+        const body = await readBody(request);
+        return reply(200, { ok: true, data: item ? store.updateItem(item[1], body) : store.clear(body) });
+      }
+      if (request.headers['transfer-encoding'] || Number(request.headers['content-length']) > 0) return fail(400, request.method === 'GET' ? '此只读接口不接受请求体' : '此接口不接受请求体');
+      if (item) {
+        if (request.method === 'DELETE') return reply(200, { ok: true, data: store.deleteItem(item[1]) });
+        const rows = store.read();
+        if (!rows.some(row => row.id === item[1])) return fail(404, '没有这条记忆');
+        return reply(200, { ok: true, data: describeMemories(rows, store.now()).find(row => row.id === item[1]) });
+      }
+      if (pathname === `${base}/api/list`) return reply(200, { ok: true, data: listMemories(store, new URLSearchParams(request.url.includes('?') ? request.url.slice(request.url.indexOf('?') + 1) : '')) });
+      if (pathname === `${base}/api/export`) {
+        const items = store.read();
+        return reply(200, { ok: true, data: { total: items.length, items } });
+      }
+      if (pathname === `${base}/api/map`) return reply(200, { ok: true, data: computeMapData(store, { warn }) });
       if (pathname === `${base}/api/stats`) return reply(200, { ok: true, data: store.stats() });
-      if (pathname === `${base}/api/config`) return reply(200, { ok: true, data: readUiConfig(path.dirname(path.dirname(store.file))) });
+      if (pathname === `${base}/api/config`) return reply(200, { ok: true, data: readUiConfig(path.dirname(path.dirname(store.file)), { warn }) });
       if (pathname === `${base}/api/onboard`) return reply(200, { ok: true, data: {
         empty: store.read().length === 0, prompt: ONBOARD_PROMPT, steps: ONBOARD_STEPS, dataDir: path.dirname(store.file),
       } });
-      const { nodes, ...data } = computeMapData(store);
+      const { nodes, ...data } = computeMapData(store, { warn });
       const html = renderHtml({ ...data, stars: nodes }, '我的记忆神经网络');
       return reply(200, html.replace('</body>', escapeBridge + '</body>'), true);
     } catch (error) {
+      if ([400, 404, 413].includes(error.status)) return fail(error.status, error.message);
       warn(`图谱请求失败：${error.message}`);
       return fail(500, '读取记忆失败，请检查本地插件日志');
     }

package/lib/store.js

@@ -83,13 +83,58 @@ export class MemoryStore {
   backup() {
     fs.mkdirSync(path.dirname(this.file), { recursive: true });
     const base = `${this.file}.bak-${Date.now()}`;
-    let file = base;
-    for (let suffix = 1; fs.existsSync(file); suffix++) file = `${base}-${suffix}`;
+    const directory = path.dirname(this.file);
+    const prefix = path.basename(base) + '-';
+    const suffixes = fs.readdirSync(directory).filter(name => name.startsWith(prefix))
+      .map(name => Number(name.slice(prefix.length))).filter(Number.isSafeInteger);
+    let suffix = suffixes.length ? Math.max(...suffixes) + 1 : 0;
+    let file = suffix ? `${base}-${suffix}` : base;
+    while (fs.existsSync(file)) file = `${base}-${++suffix}`;
     if (fs.existsSync(this.file)) fs.copyFileSync(this.file, file, fs.constants.COPYFILE_EXCL);
     else fs.writeFileSync(file, '[]\n', { flag: 'wx', mode: 0o600 });
+    const backups = fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+      const match = /^memories\.json\.bak-(\d+)(?:-(\d+))?$/u.exec(entry.name);
+      return entry.isFile() && match ? [{ name: entry.name, time: Number(match[1]), suffix: Number(match[2] ?? 0) }] : [];
+    }).sort((left, right) => right.time - left.time || right.suffix - left.suffix);
+    for (const old of backups.slice(5)) fs.unlinkSync(path.join(directory, old.name));
     return file;
   }
 
+  updateItem(id, changes) {
+    const invalid = message => { throw Object.assign(new Error(message), { status: 400 }); };
+    if (!changes || typeof changes !== 'object' || Array.isArray(changes)) invalid('请求体必须是 JSON 对象');
+    for (const key of Object.keys(changes)) {
+      if (!['text', 'kind', 'heat', 'who'].includes(key)) invalid(`不支持修改 ${key}`);
+    }
+    if (Object.hasOwn(changes, 'text') && (!nonempty(changes.text) || Array.from(changes.text).length > 2000)) invalid('text 必须是 1～2000 字符，且不能全为空白');
+    if (Object.hasOwn(changes, 'kind') && (!nonempty(changes.kind) || Array.from(changes.kind).length > 20)) invalid('kind 必须是 1～20 字符');
+    if (Object.hasOwn(changes, 'heat') && ![1, 2, 3].includes(changes.heat)) invalid('heat 必须是整数 1、2 或 3');
+    if (Object.hasOwn(changes, 'who') && (typeof changes.who !== 'string' || Array.from(changes.who).length > 40)) invalid('who 必须是 0～40 字符');
+    const rows = this.read();
+    const index = rows.findIndex(row => row.id === id);
+    if (index === -1) throw Object.assign(new Error('没有这条记忆'), { status: 404 });
+    rows[index] = { ...rows[index], ...changes };
+    const backup = this.backup();
+    this.write(rows);
+    return { ...rows[index], backup };
+  }
+
+  deleteItem(id) {
+    const rows = this.read();
+    if (!rows.some(row => row.id === id)) throw Object.assign(new Error('没有这条记忆'), { status: 404 });
+    const backup = this.backup();
+    this.write(rows.filter(row => row.id !== id));
+    return { deleted: id, backup };
+  }
+
+  clear({ confirm } = {}) {
+    if (confirm !== 'DELETE') throw Object.assign(new Error('请输入大写 DELETE 确认清空'), { status: 400 });
+    const rows = this.read();
+    const backup = this.backup();
+    this.write([]);
+    return { removed: rows.length, backup };
+  }
+
   dedupe({ threshold = 0.7, dry_run = true } = {}) {
     if (typeof dry_run !== 'boolean') throw new Error('dry_run 必须是布尔值');
     const started = performance.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-engine",
-  "version": "0.7.0-beta.2b",
+  "version": "0.7.0-beta.4",
   "description": "Local DSH memory engine with neuron network visualization and private file import",
   "keywords": [
     "dsh",