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

package/lib/auto-sources.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { collectBridge } from './import.js';
+import { collectFile } from './file-import.js';
+
+function inside(root, file) {
+  const relative = path.relative(root, file);
+  return relative === '' || (!relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+export async function sourceFiles(source, warn) {
+  if (!path.isAbsolute(source.path)) throw new Error('自动导入 path 必须是绝对路径');
+  const requested = path.resolve(source.path);
+  const root = await fs.realpath(requested);
+  if (root !== requested) throw new Error('自动导入根路径包含软链接，请直接配置真实路径');
+  const info = await fs.stat(root);
+  const files = [];
+  async function checked(file) {
+    const real = await fs.realpath(file);
+    if (!inside(root, real)) throw new Error(`源文件软链接超出配置目录：${file}`);
+    return real;
+  }
+  async function walk(directory, extension, recursive) {
+    const real = await checked(directory);
+    for (const entry of (await fs.readdir(real, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name))) {
+      const file = path.join(real, entry.name);
+      try {
+        const resolved = await checked(file);
+        if (entry.isSymbolicLink()) continue;
+        if (entry.isDirectory() && recursive) await walk(resolved, extension, true);
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(extension) && (source.type !== 'diary' || !entry.name.startsWith('_'))) files.push(resolved);
+      } catch (error) { warn(error.message, { once: true }); }
+    }
+  }
+  if (['json', 'text'].includes(source.type)) {
+    if (!info.isFile()) throw new Error(`${source.type} 必须是文件`);
+    return { root, files: [root] };
+  }
+  if (!info.isDirectory()) throw new Error(`${source.type} 必须是目录`);
+  if (source.type === 'bridge') {
+    for (const name of ['state/knowledge.json', 'state/social-v2.json', 'state/starmap/stars.json', 'state/slang.json']) {
+      try { const file = await checked(path.join(root, name)); if ((await fs.stat(file)).isFile()) files.push(file); }
+      catch (error) { warn(`略过 ${path.join(root, name)}：${error.message}`, { once: true }); }
+    }
+    try { await walk(path.join(root, 'state/history'), '.jsonl', false); }
+    catch (error) { warn(`略过 history：${error.message}`, { once: true }); }
+  } else await walk(root, '.md', source.type === 'markdown');
+  return { root, files };
+}
+
+export async function verifySource(root, file) {
+  const realRoot = await fs.realpath(root);
+  const real = await fs.realpath(file);
+  if (realRoot !== root || !inside(root, real) || real !== file) throw new Error(`源路径发生变化，已略过：${file}`);
+}
+
+export async function readJsonl(file, previous, info) {
+  const reset = !previous || info.size < (previous.bytes ?? 0) || (info.size === previous.size && info.mtimeMs !== previous.mtime);
+  const base = reset ? {} : previous;
+  const start = base.bytes ?? 0;
+  const end = base.pending?.bytes ?? info.size;
+  const descriptor = await fs.open(file, 'r');
+  let buffer;
+  try {
+    buffer = Buffer.alloc(Math.max(0, end - start));
+    let offset = 0;
+    while (offset < buffer.length) {
+      const { bytesRead } = await descriptor.read(buffer, offset, buffer.length - offset, start + offset);
+      if (!bytesRead) throw new Error('读取期间源文件被截短');
+      offset += bytesRead;
+    }
+  } finally { await descriptor.close(); }
+  let content = buffer.toString('utf8');
+  const finalBreak = content.lastIndexOf('\n');
+  const tail = content.slice(finalBreak + 1);
+  if (tail.trim()) {
+    try { JSON.parse(tail); }
+    catch { content = content.slice(0, finalBreak + 1); }
+  }
+  const lines = content ? content.split('\n').length - (content.endsWith('\n') ? 1 : 0) : 0;
+  return { content, bytes: start + Buffer.byteLength(content), lines: (base.lines ?? 0) + lines,
+    offset: base.pending?.offset ?? 0, base: { bytes: start, lines: base.lines ?? 0 } };
+}
+
+export async function parseSourceFile(source, root, file, info, content, now) {
+  if (!['bridge', 'diary'].includes(source.type)) {
+    const collection = await collectFile({ source: source.type, path: source.type === 'markdown' ? root : file,
+      ...(source.type === 'markdown' ? { files: [file] } : {}) }, now);
+    return collection.entries.map(entry => ({ ...entry, origin: { source: source.type, file } }));
+  }
+  const isDiary = path.extname(file).toLowerCase() === '.md';
+  const selected = path.resolve(file);
+  const body = content ?? await fs.readFile(selected, 'utf8');
+  if (path.extname(file) === '.json') JSON.parse(body.replace(/^\uFEFF/u, ''));
+  const collection = collectBridge({ root, diaryDir: isDiary ? path.dirname(selected) : '', io: {
+    readFileSync(input) {
+      if (path.resolve(input) === selected) return body;
+      return /(?:knowledge|slang)\.json$/u.test(input) ? '[]' : '{}';
+    },
+    readdirSync(directory) {
+      return path.resolve(directory) === path.dirname(selected) ? [{ name: path.basename(selected), isFile: () => true }] : [];
+    },
+    statSync() { return info; },
+  } });
+  return collection.entries.map(entry => ({ ...entry, origin: { source: source.type, file } }));
+}

package/lib/automation-config.js

@@ -0,0 +1,66 @@
+export const memoryDefaults = Object.freeze({ enabled: true, provider: 'deepseek-account', model: 'deepseek-flash',
+  maxPerTurn: 2, minChars: 12, dailyCap: 40, cooldownSec: 30,
+  excludePatterns: Object.freeze(['密码', '身份证', '银行卡', '手机号', '验证码']) });
+
+function object(value, name) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${name} 必须是对象`);
+}
+
+function enabled(value) {
+  if (typeof value !== 'boolean') throw new Error('enabled 必须是布尔值');
+}
+
+function range(value, name, minimum, maximum) {
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw new Error(`${name} 必须是 ${minimum}～${maximum} 的整数`);
+}
+
+export function automationConfig(config = {}, warn = () => {}) {
+  let autoMemory = { ...memoryDefaults, excludePatterns: [...memoryDefaults.excludePatterns] };
+  const sources = [{ type: 'dsh-sessions' }];
+  if (config.bridgeRoot) sources.push({ type: 'bridge', path: config.bridgeRoot });
+  if (config.diaryDir) sources.push({ type: 'diary', path: config.diaryDir });
+  let autoImport = { enabled: true, importAssistant: false, noisePatterns: [], rescanAll: false,
+    sources, intervalMinutes: 60, maxPerRun: 200 };
+  try {
+    if (config.autoMemory !== undefined) object(config.autoMemory, 'autoMemory');
+    autoMemory = { ...autoMemory, ...config.autoMemory };
+    enabled(autoMemory.enabled);
+    for (const key of ['provider', 'model']) {
+      if (typeof autoMemory[key] !== 'string' || !autoMemory[key].trim()) throw new Error(`${key} 不能为空`);
+      autoMemory[key] = autoMemory[key].trim();
+    }
+    range(autoMemory.maxPerTurn, 'maxPerTurn', 1, 5);
+    range(autoMemory.minChars, 'minChars', 4, 200);
+    range(autoMemory.dailyCap, 'dailyCap', 0, 500);
+    range(autoMemory.cooldownSec, 'cooldownSec', 0, 3600);
+    if (!Array.isArray(autoMemory.excludePatterns) || autoMemory.excludePatterns.length > 20
+      || autoMemory.excludePatterns.some(pattern => typeof pattern !== 'string' || !pattern.trim())) throw new Error('excludePatterns 必须是最多 20 个非空字符串');
+  } catch (error) {
+    warn(`自动记忆配置无效，已停用：${error.message}`);
+    autoMemory = { ...memoryDefaults, enabled: false };
+  }
+  try {
+    if (config.autoImport !== undefined) object(config.autoImport, 'autoImport');
+    autoImport = { ...autoImport, ...config.autoImport };
+    enabled(autoImport.enabled);
+    if (typeof autoImport.importAssistant !== 'boolean') throw new Error('importAssistant 必须是布尔值');
+    if (typeof autoImport.rescanAll !== 'boolean') throw new Error('rescanAll 必须是布尔值');
+    if (autoImport.rescanFrom !== undefined && (typeof autoImport.rescanFrom !== 'string' || !autoImport.rescanFrom.trim())) throw new Error('rescanFrom 必须是非空 sessionId');
+    if (!Array.isArray(autoImport.noisePatterns) || autoImport.noisePatterns.some(pattern => typeof pattern !== 'string' || !pattern.trim())) throw new Error('noisePatterns 必须是非空字符串数组');
+    range(autoImport.intervalMinutes, 'intervalMinutes', 1, 10080);
+    range(autoImport.maxPerRun, 'maxPerRun', 1, 10000);
+    if (!Array.isArray(autoImport.sources)) throw new Error('sources 必须是数组');
+    autoImport.sources = autoImport.sources.map(source => {
+      object(source, 'source');
+      if (!['dsh-sessions', 'bridge', 'diary', 'json', 'markdown', 'text'].includes(source.type)) throw new Error(`未知来源 ${source.type}`);
+      if (source.type !== 'dsh-sessions' && (typeof source.path !== 'string' || !source.path.trim())) throw new Error(`${source.type} 缺少 path`);
+      return source.type === 'dsh-sessions' ? { type: source.type } : { type: source.type, path: source.path };
+    });
+    autoImport.sources.sort((left, right) => Number(right.type === 'dsh-sessions') - Number(left.type === 'dsh-sessions'));
+  } catch (error) {
+    warn(`自动导入配置无效，已停用：${error.message}`);
+    autoImport = { enabled: false, importAssistant: false, noisePatterns: [], rescanAll: false,
+      sources: [], intervalMinutes: 60, maxPerRun: 200 };
+  }
+  return { autoMemory, autoImport };
+}

package/lib/automation-state.js

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+export function readState(file, fallback) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/u, '')); }
+  catch (error) { if (error.code === 'ENOENT') return fallback; throw error; }
+}
+
+export function writeState(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(value, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+    fs.renameSync(temporary, file);
+  } finally {
+    try { fs.unlinkSync(temporary); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+}
+
+export function localDay(time) {
+  const date = new Date(time);
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+}
+
+export function warningLogger(warn, now = Date.now) {
+  const seen = new Set();
+  const times = new Map();
+  return (message, { once = false, key = 'runtime' } = {}) => {
+    if (once ? seen.has(message) : now() - (times.get(key) ?? -Infinity) < 60000) return;
+    if (once) seen.add(message); else times.set(key, now());
+    try { warn(message); } catch {}
+  };
+}
+
+export function service(ctx, name) {
+  try { return ctx?.get?.(name); } catch { return undefined; }
+}
+
+export function backupForAutomation(store, warn) {
+  try { store.backup(); }
+  catch (error) { warn(`自动记忆备份失败，继续写库：${error.message}`, { key: 'backup' }); }
+}

package/lib/classify.js

@@ -0,0 +1,11 @@
+export function classifyImport(text, sourceHint = '') {
+  const file = typeof sourceHint === 'string' ? sourceHint : sourceHint?.file ?? sourceHint?.path ?? '';
+  const value = typeof text === 'string' ? text.trim() : '';
+  if (/(?:^|[/\\])\d{4}-\d{2}-\d{2}\.md$/iu.test(file)) return { kind: '日记', heat: 2 };
+  if (/价格|多少钱|几块|块一杯|元/u.test(value)) return { kind: '知识', heat: 2 };
+  if (/^(?:是什么|怎么|为什么|意思是)/u.test(value)) return { kind: '知识', heat: 2 };
+  if (/过敏|不吃|不喜欢|怕|讨厌|最爱/u.test(value)) return { kind: '印象', heat: 1 };
+  if (/答应|约好|下次|明天|说好/u.test(value)) return { kind: '事件', heat: 2 };
+  if (value.startsWith('#') && /\d{4}(?:[-/.]\d{1,2}[-/.]\d{1,2}|年\d{1,2}月\d{1,2}日)/u.test(value)) return { kind: '日记', heat: 2 };
+  return { kind: '对话', heat: 2 };
+}

package/lib/client.js

@@ -22,15 +22,18 @@ window.__ModuleLoader__.load({
   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 = [];
+  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 spinSpeed=data.spinSpeed??0.35,resumeAt=0;
-  let drag=null,nextFire=0,lastTime=0,rafId=null,running=false,destroyed=false,generation=0,observer=null;
+  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');
@@ -62,6 +65,8 @@ function glowSprite(rgb) {
     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, []);
@@ -87,6 +92,23 @@ function glowSprite(rgb) {
         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));
@@ -123,17 +145,19 @@ function project(pos) {
 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));
+  // 选中某个光点时，把它的关联线都点亮几条脉冲（最多 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++<200) {
+  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(0.26,firing.get(other)||0));
+    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});
   }
 }
@@ -149,6 +173,8 @@ 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));
   }
@@ -187,10 +213,16 @@ function frame(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);
+    // 默认不画连线，所以也不撒"沿线的脉冲"——否则会出现飘来飘去的小点，找不到来源。
+    // 选中光点后，脉冲只在它的关联线上跑。
+    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;
   }
@@ -208,37 +240,37 @@ function frame(now) {
   }
   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();
+  // 连线只在"选中某个光点"时画，且只画和它相连的那些。
+  // 全量 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;
@@ -323,6 +355,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);
     }
@@ -537,7 +576,7 @@ function frame(now) {
         setError("");
         readApi("/memory-engine/api/map", controller.signal).then(function (nextData) {
           if (!active) return;
-          renderer = createRenderer(canvas.current, nextData);
+          renderer = createRenderer(canvas.current, nextData, { frameInterval: 25 });
           props.rendererRef.current = renderer;
           renderer.onSelect(function (node) { props.selectionVersion.current++; props.onSelect(node); });
           renderer.start();
@@ -577,7 +616,7 @@ function frame(now) {
             React.createElement("span", { style: { width: "52px", height: "5px", borderRadius: "5px", background: "#335066", overflow: "hidden" } },
               React.createElement("i", { style: { display: "block", height: "100%", background: "#6bc9fa", width: Math.min(100, Math.max(0, item.retention * 100)) + "%" } })));
         })) : null,
-        React.createElement("div", { style: { position: "absolute", right: "18px", bottom: "18px", pointerEvents: "none", color: "#7b99ad", font: "13px system-ui,sans-serif" } }, "拖拽旋转 · 滚轮缩放 · 点击选中神经元"),
+        React.createElement("div", { style: { position: "absolute", right: "18px", bottom: "18px", pointerEvents: "none", color: "#7b99ad", font: "13px system-ui,sans-serif" } }, "拖拽旋转 · 滚轮缩放 · 点光点看关联"),
         error ? React.createElement("div", { role: "alert", style: { position: "absolute", inset: "40% 20% auto", textAlign: "center", color: "#d8e9f8" } },
           React.createElement("p", null, "图谱加载失败：" + error),
           React.createElement("button", { type: "button", style: actionStyle, onClick: function () { setRetry(function (value) { return value + 1; }); } }, "重试")) : null);

package/lib/client.src.js

@@ -188,7 +188,7 @@ window.__ModuleLoader__.load({
         setError("");
         readApi("/memory-engine/api/map", controller.signal).then(function (nextData) {
           if (!active) return;
-          renderer = createRenderer(canvas.current, nextData);
+          renderer = createRenderer(canvas.current, nextData, { frameInterval: 25 });
           props.rendererRef.current = renderer;
           renderer.onSelect(function (node) { props.selectionVersion.current++; props.onSelect(node); });
           renderer.start();
@@ -228,7 +228,7 @@ window.__ModuleLoader__.load({
             React.createElement("span", { style: { width: "52px", height: "5px", borderRadius: "5px", background: "#335066", overflow: "hidden" } },
               React.createElement("i", { style: { display: "block", height: "100%", background: "#6bc9fa", width: Math.min(100, Math.max(0, item.retention * 100)) + "%" } })));
         })) : null,
-        React.createElement("div", { style: { position: "absolute", right: "18px", bottom: "18px", pointerEvents: "none", color: "#7b99ad", font: "13px system-ui,sans-serif" } }, "拖拽旋转 · 滚轮缩放 · 点击选中神经元"),
+        React.createElement("div", { style: { position: "absolute", right: "18px", bottom: "18px", pointerEvents: "none", color: "#7b99ad", font: "13px system-ui,sans-serif" } }, "拖拽旋转 · 滚轮缩放 · 点光点看关联"),
         error ? React.createElement("div", { role: "alert", style: { position: "absolute", inset: "40% 20% auto", textAlign: "center", color: "#d8e9f8" } },
           React.createElement("p", null, "图谱加载失败：" + error),
           React.createElement("button", { type: "button", style: actionStyle, onClick: function () { setRetry(function (value) { return value + 1; }); } }, "重试")) : null);

package/lib/config.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { automationConfig } from './automation-config.js';
+import { readLastError } from './auto-log.js';
 
 export const defaultHome = () => process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
 
@@ -11,7 +13,10 @@ export function resolveDiaryDir({ home = defaultHome(), envDir = process.env.QQ_
 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 };
+    hasPersona: readPersona(config, options) !== null, personaTitle: config.personaTitle, spinSpeed: config.spinSpeed,
+    autoMemory: { enabled: config.autoMemory.enabled, maxPerTurn: config.autoMemory.maxPerTurn },
+    autoImport: { enabled: config.autoImport.enabled, sourceCount: config.autoImport.sources.length },
+    lastError: readLastError(path.join(home, 'memory-engine', 'auto-log.json'), options.warn) };
 }
 
 export function readPersona(config, { now = Date.now(), warn = message => console.warn(`[dsh-memory-engine] ${message}`) } = {}) {
@@ -34,7 +39,7 @@ export function readPersona(config, { now = Date.now(), warn = message => consol
   }
 }
 
-export function readConfig(home = defaultHome()) {
+export function readConfig(home = defaultHome(), { warn } = {}) {
   const file = path.join(home, 'memory-engine', 'config.json');
   try {
     const value = JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/u, ''));
@@ -46,9 +51,9 @@ export function readConfig(home = defaultHome()) {
     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 };
+    return { ...value, personaTitle: value.personaTitle?.trim() || '角色卡', spinSpeed: value.spinSpeed ?? 0.35, ...automationConfig(value, warn) };
   } catch (error) {
-    if (error.code === 'ENOENT') return { personaTitle: '角色卡', spinSpeed: 0.35 };
+    if (error.code === 'ENOENT') return { personaTitle: '角色卡', spinSpeed: 0.35, ...automationConfig({}, warn) };
     throw new Error(`无法读取 ${file}：${error.message}`);
   }
 }

package/lib/dedupe.js

@@ -49,10 +49,10 @@ export function similarity(a, b, threshold = 0.7) {
   return { duplicate: score >= threshold, score, rule: 'lcs' };
 }
 
-export function findDuplicate(rows, candidate, prepared = rows.map(row => prepare(row.text))) {
+export function findDuplicate(rows, candidate, prepared = rows.map(row => prepare(row.text)), threshold = 0.7) {
   const text = prepare(candidate.text);
   for (let index = 0; index < rows.length; index++) {
-    const match = similarity(prepared[index], text);
+    const match = similarity(prepared[index], text, threshold);
     if (match.duplicate) return { index, ...match };
   }
   return null;

package/lib/file-import.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { loadMemories } from './render/index.mjs';
 import { inferEmotion } from './decay.js';
 
-export async function collectFile({ source, path: input }, now = Date.now()) {
+export async function collectFile({ source, path: input, files: selectedFiles }, now = Date.now()) {
   if (!['json', 'markdown', 'text'].includes(source)) throw new Error('source 支持 qq-bridge / json / markdown / text');
   if (typeof input !== 'string' || !path.isAbsolute(input)) throw new Error('path 必须是本地文件或目录的绝对路径');
   const info = await fs.stat(input);
@@ -13,15 +13,16 @@ export async function collectFile({ source, path: input }, now = Date.now()) {
   try {
     let loaderInput = input;
     if (source === 'markdown') {
-      const files = (await fs.readdir(input, { recursive: true, withFileTypes: true }))
+      const files = selectedFiles ?? (await fs.readdir(input, { recursive: true, withFileTypes: true }))
         .filter(entry => entry.isFile() && path.extname(entry.name).toLowerCase() === '.md')
         .map(entry => path.join(entry.parentPath, entry.name));
       const contents = await Promise.all(files.map(async file => ({ file, text: await fs.readFile(file, 'utf8'), info: await fs.stat(file) })));
-      if (contents.some(item => item.text.startsWith('\uFEFF'))) {
+      if (selectedFiles || contents.some(item => item.text.startsWith('\uFEFF'))) {
         temporary = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-memory-input-'));
         loaderInput = temporary;
         for (const item of contents) {
           const target = path.join(temporary, path.relative(input, item.file));
+          if (path.relative(temporary, target).startsWith('..') || path.isAbsolute(path.relative(temporary, target))) throw new Error('Markdown 文件超出导入目录');
           await fs.mkdir(path.dirname(target), { recursive: true });
           await fs.writeFile(target, item.text.replace(/^\uFEFF/u, ''));
           await fs.utimes(target, item.info.atime, item.info.mtime);

package/lib/import.js

@@ -34,15 +34,18 @@ export function resolveBridgeRoot({ defaultRoot = DEFAULT_BRIDGE_ROOT, envRoot =
 }
 
 export function collectBridge(options = {}) {
-  const root = resolveBridgeRoot(options);
+  const root = options.root ?? resolveBridgeRoot(options);
   if (!root) return { missing: true, entries: [], warnings: [], counts: {} };
+  const readSource = options.io?.readFileSync ?? readFileSync;
+  const listSource = options.io?.readdirSync ?? readdirSync;
+  const statSource = options.io?.statSync ?? statSync;
   const warnings = [];
   const readJson = (file, fallback) => {
-    try { return JSON.parse(readFileSync(file, 'utf8').replace(/^\uFEFF/u, '')); }
+    try { return JSON.parse(readSource(file, 'utf8').replace(/^\uFEFF/u, '')); }
     catch (error) { warnings.push(`${file}：${error.code === 'ENOENT' ? '未找到，已略过' : '无法读取或 JSON 损坏，已略过'}`); return fallback; }
   };
   const files = directory => {
-    try { return readdirSync(directory, { withFileTypes: true }).filter(entry => entry.isFile()).map(entry => entry.name).sort(); }
+    try { return listSource(directory, { withFileTypes: true }).filter(entry => entry.isFile()).map(entry => entry.name).sort(); }
     catch { warnings.push(`${directory}：无法读取目录，已略过`); return []; }
   };
   const state = path.join(root, 'state');
@@ -117,7 +120,7 @@ export function collectBridge(options = {}) {
   for (const file of (diaryDir ? files(diaryDir) : []).filter(name => !name.startsWith('_') && name.toLowerCase().endsWith('.md'))) {
     const full = path.join(diaryDir, file);
     try {
-      add('日记', { text: readFileSync(full, 'utf8'), kind: '日记', ts: statSync(full).mtimeMs, title: path.basename(file, path.extname(file)) },
+      add('日记', { text: readSource(full, 'utf8'), kind: '日记', ts: statSource(full).mtimeMs, title: path.basename(file, path.extname(file)) },
         full, [`diary-${file}`]);
     } catch { warnings.push(`${file}：日记无法读取，已略过`); }
   }
@@ -132,7 +135,7 @@ export function collectBridge(options = {}) {
   const todayMessages = [];
   for (const file of files(path.join(state, 'history')).filter(name => name.endsWith('.jsonl'))) {
     let lines;
-    try { lines = readFileSync(path.join(state, 'history', file), 'utf8').replace(/^\uFEFF/u, '').split(/\r?\n/u); }
+    try { lines = readSource(path.join(state, 'history', file), 'utf8').replace(/^\uFEFF/u, '').split(/\r?\n/u); }
     catch { warnings.push(`${file}：历史文件无法读取，已略过`); continue; }
     let broken = 0;
     for (const line of lines) {