dsh-memory-engine 0.7.0 → 0.7.5

package/README.md

@@ -1,8 +1,8 @@
-# DSH 记忆引擎
+# DSH 记忆引擎
 
 DSH 插件的本地记忆引擎，带神经网络可视化。它让 agent 保存、召回和管理跨会话记忆，也能把你已有的记忆文件导进来。
 
-当前版本：0.7.0。Node ≥22，零新增依赖。自动记忆默认关闭，由用户在图谱头部或设置页手动打开；开启后每轮对话会额外调用一次模型，可能产生费用。自动导入默认只收用户消息，支持流程话过滤、规则分类、错误原因和一次性重扫。
+当前版本：0.7.5。Node ≥22，零新增依赖。自动记忆默认关闭，由用户在图谱头部或设置页手动打开；开启后每轮对话会额外调用一次模型，可能产生费用。自动导入默认只收聊天会话的用户消息，支持来源白名单、工作指令过滤、流程话过滤、规则分类、错误原因、一次性重扫和账本清理。
 
 ## 从 0.6.1 升级到 0.7.0 的变化
 
@@ -136,7 +136,7 @@ peerDependencies 已放宽为 >=0.1.0-rc.8 <0.3.0 并标为 optional——宿主
 
 JSON 成功返回 `{ "ok": true, "data": ... }`，失败返回 `{ "ok": false, "error": "说明" }`。既有接口返回结构保留；stats/list/export 仍只统计实际记忆。接口仅接受本机 Host，严格限制路径，拒绝路径穿越；不允许的方法返回 405。只读接口不接收请求体，PUT 和 POST 只接收 JSON 对象，声明大小和实际分块累计大小都限制在 1MB。
 
-配置 PUT 使用嵌套对象，例如 `{ "autoMemory": { "enabled": false } }`。只允许 `autoMemory.enabled`、`autoImport.enabled`、`autoMemory.maxPerTurn`（1～5 整数）、`autoMemory.dailyCap`（0～500 整数）、`spinSpeed`（0.05～1.5 数字）、`showGuideOnEmpty` 和 `hideButton`；所有启用/显示开关只接受布尔值。任何未知字段或类型错误会整次返回 400，不改任何字段。角色卡、来源路径、模型等不能通过此接口修改。
+配置 PUT 使用嵌套对象，例如 `{ "autoMemory": { "enabled": false } }`。只允许 `autoMemory.enabled`、`autoImport.enabled`、`autoMemory.maxPerTurn`（1～5 整数）、`autoMemory.dailyCap`（0～500 整数）、`spinSpeed`（0.05～1.5 数字）、`showGuideOnEmpty` 和 `hideButton`；所有启用/显示开关只接受布尔值。0.7.2 新增 `autoImport.importAssistant`（布尔值）、`autoImport.workMarkers` 和 `autoImport.sessionFilter`，校验规则见下节；sessionFilter 的局部更新保留未提供的旧字段。任何未知字段或类型错误会整次返回 400，不改任何字段。角色卡、来源路径、模型等不能通过此接口修改；GET 的公开字段保持原样。
 
 配置写入前生成 `config.json.bak-<时间戳>`，同毫秒加序号，保留最近五份；先写临时文件再 rename。备份或写入失败保留原配置。首次成功启用时，服务端自行保存 `showAutoMemoryCostHint: false`，不向客户端额外开放这个字段的写权限。关闭会清空当前收集的对话、取消排队和进行中的抽取，重新开启时重置冷却和失败退避；自动导入独立运行，若要冻结所有自动入库，需同时关闭它。
 
@@ -176,6 +176,10 @@ memory_map(out="D:\\memory-map.html")
     "enabled": true,
     "importAssistant": false,
     "noisePatterns": [],
+    "workMarkers": [],
+    "sessionFilter": { "mode": "include", "cwdContains": ["state/agents", "qq-bridge", "astrbot", "nonebot", "koishi"], "maxToolCalls": 0 },
+    "ledgerRetentionDays": { "skip": 30, "session": 120 },
+    "ledgerMaxEntries": 2000,
     "sources": [{ "type": "dsh-sessions" }],
     "intervalMinutes": 60,
     "maxPerRun": 200
@@ -191,6 +195,49 @@ memory_map(out="D:\\memory-map.html")
 
 会话导入仅通过 `sessionQuery.listSessions/readSession`，不直接读取或解压会话文件，不激活会话。默认 `importAssistant=false`，只收 `user/message`；改为 true 才额外收 `assistant/message`，两者都过滤流程话。此开关不影响自定义路径中的日记等正文。保留事件发生时间；连续重复、寒暄、纯代码块和敏感词仍被过滤，超过 2000 字的消息拆段保存。每会话每轮最多 200 条，全局默认最多 200 条，批间让出 20 毫秒。`import-ledger.json` 保存 seq、文件 size/mtime、JSONL 行数/字节位置及未完成批次，超限下轮继续。重复导入不强化旧记忆。
 
+0.7.2 在读取消息和写入候选两个位置检查 `importAssistant`。运行中关闭后，尚未写入的 assistant 候选也会被拦住；运行中开启从下一轮生效。已有 assistant 存量不会自动删除。
+
+`autoImport.sessionFilter` 只影响 dsh-sessions 来源，读取事件后先判断整段会话，再收集消息：
+
+0.7.5 默认使用 `include` 来源白名单。常见聊天目录为 `state/agents`、`qq-bridge`、`astrbot`、`nonebot` 和 `koishi`；这些默认提示按完整目录段匹配，避免把 `qq-bridge-probe` 当成聊天目录。自定义 `cwdContains` 仍可填写路径片段。没有会话命中时，设置页会提示并提供「改用宽松模式」按钮；点击后保存 `mode: auto`，立即重新尝试此前跳过的会话。普通 DSH 聊天如不在这些目录，可在 `config.json` 设置 `{ "autoImport": { "sessionFilter": { "mode": "auto" } } }`；需要收全部会话则设 `mode: all`。聊天机器人可配置 `{ "mode": "include", "cwdContains": ["state/agents", "qq-bridge"] }`。
+
+0.7.4 在自动导入时直接丢弃桥接聊天记录、运行时快照、`<message source_id=...>`、会话令牌和 Runtime/Context 包装文本。`dsh-sessions` 消息默认至少 12 个 Unicode 字符，可在 `config.json` 的 `autoImport.minChars` 设为 4～200；手动 `memory_import` 和 QQ 文件来源不受此门槛影响。自动导入的长文本若前 50 个字符与已存条目相同，只保留先入库的一条。配置 `personaFile` 后，导入器还会跳过与角色卡正文高度重合的会话文本。在 auto 会话模式下，工作区中的无工具会话若用户消息命中至少两组工作词，也会整段跳过。这些规则只影响新导入，不删除已有记忆。
+
+| mode | 行为 |
+|---|---|
+| `auto`（默认） | 至少 2 条 user/message；工作工具调用次数不超过 maxToolCalls（默认 0） |
+| `include` | cwd 包含 cwdContains 中任一路径片段；忽略大小写并统一斜杠。空列表全部排除，不附加 auto 的工具条件 |
+| `all` | 不限制会话类型或消息条数，角色和内容过滤仍然生效 |
+
+工作工具包括 `pwsh/bash/read/write/edit/grep/glob/subagent/workflow/notebook`，也识别带命名空间的名称；`qq_*` 和记忆工具不计入。maxToolCalls 只能为 0～10000 的整数；cwdContains 最多 50 个非空片段，每个最长 1000 字符，未知字段会被拒绝。QQ 会话如果也调用过工作工具，auto 同样跳过，可按实际需要选择 include。
+
+跳过结果保存在 `import-ledger.json` 的 `session:<id>.skip`，含 sessionId、模式和原因：`work-tools`、`cwd-excluded` 或 `too-few-user-messages`。前两种在同一规则下直接复用账本，日志汇总跳过的工作会话及工具；不足两条消息的会话下轮再检查，以免永远漏掉后续聊天。修改过滤规则或使用 rescanFrom/rescanAll 会重新判断。跳过不会删除已经入库的记忆，也不把该会话的旧水位推进到结尾。
+
+工作指令单独按六组特征计数：记忆工具名、插件配置名、任务/验收词、构建发布词、版本号、录屏演示词。通常命中至少两组才拦截，单独说“npm 这个包挺好用的”仍保留。0.7.3 收紧一个弱组合：只命中构建/软件词和版本号两组时保留，避免将“新版已发布，朋友可安装”误判为工作指令；再命中验收、工具调用等第三组时仍拦截。`autoImport.workMarkers` 可追加最多 20 个正则源码字符串（每个最长 300 字符，使用 iu 标志）；无效正则拒绝保存，手工写入无效配置则停用自动导入并提示。会话消息在拆段前检查完整正文，路径来源在写入前也检查。旧流程话规则独立保留。
+
+### 导入账本清理
+
+每轮自动导入结束时检查一次 `import-ledger.json`，只有实际删除记录或过期 skip 缓存时才调用已有 automation-state 原子写；无变化时不写盘。默认无水位 skip 缓存按 skip.at 超过 30 天删除，会话水位按 importedAt 超过 120 天未更新才删除。重新判断 skip 不会延长旧水位的寿命；不认识对应时间的旧记录保留。
+
+同一记录同时包含水位和 skip 时，水位按 120 天保留，过期 30 天的 skip 字段可以单独清除，下轮重新判断会话。文件来源的字节/行数进度、未完成分段、重扫任务均保留。导入中刚更新的水位不会因清理而丢失。
+
+条目数超过 `ledgerMaxEntries`（默认 2000）时，按更新时间从旧到新淘汰**没有水位**的 skip 缓存，目标为上限的 75%（默认 1500）。容量压力下这种可重新判断的缓存可以提前淘汰；仍不动近期水位。如果全部都是受保护的水位或文件进度，允许暂时超过上限并告警，不能为凑数量造成重新导入。
+
+在 config.json 的 autoImport 中设置 `ledgerRetentionDays` 和 `ledgerMaxEntries`；本版没有增加配置 PUT 白名单或界面入口。skip 天数范围为 30～36500，session 为 120～36500，条目上限为 1～100000，均为整数。非法配置会中止本轮导入并记录原因，不会按错误期限清库。日志分别报告过期删除、单独清除 skip 字段、容量淘汰及清理前后数量。近期账本即使有很多 skip，也不会为了显示“条数下降”提前按过期规则删除。
+
+### 存量清理（逐步确认）
+
+`scripts/cleanup-imports.mjs` 默认只预览。依次运行 assistant、work、dedupe，每一步先看完整 JSON 清单和终端前 10 条样本，获得用户确认后才执行。清单包含库指纹和确认 token，库或规则变化时必须重新预览。执行前关闭 DSH，避免另一个进程同时写库。
+
+```sh
+node scripts/cleanup-imports.mjs --home <DSH目录> --stage assistant --out <assistant-preview.json>
+node scripts/cleanup-imports.mjs --home <DSH目录> --preview <assistant-preview.json> --confirm <该清单token>
+```
+
+第一步完成后对 work 重复预览和确认，再对 dedupe 重复；不能越过尚未完成的前一步。删除调用现成 store.backup()/write()，合并调用 store.dedupe({ dry_run: false })，默认阈值 0.7。每一步自动备份、写后核对数量；备份失败立即中止。QQ 来源匹配项保护保留并列在 protected 中。去重预览如果会减少 QQ 来源条数，blocked 为 true，执行会拒绝；先审阅冲突组，不自动更改来源或去重算法。无变更时不写库。
+
+需要保留 QQ 冲突组、只合并其余组时，在 dedupe 预览命令增加 `--protect-qq`。清单的 protected 列出整个冲突组的所有条目，确认后这些条目原样保留；其余范围仍调用现成 store.dedupe，备份保存完整原库，最终写入仍走 store.write。必须审阅这份新清单后再确认，不能沿用未保护的合并清单。
+
 流程话过滤采用固定词表，可在 `autoImport.noisePatterns` 追加字面短语。命中两个不同特征即拦截；只命中一个时，仅拦截不足 150 字的文本，长内容保留。开头 12 字内出现「已回：」「已回复：」「已发送：」「已处理：」「已确认：」「已读：」「已标记：」「回过了：」「发过了：」的工作汇报，无论长度都拦截；中间提到「他说已回复了」不算前缀。自动记忆的抽取结果也通过同一过滤器。规则只作用于后续入库，不追删旧条目。
 
 新导入的会话按顺序粗分：日期命名的 Markdown 日记 → 日记；价格或解释 → 知识；过敏、忌口或偏好 → 印象；约定或计划 → 事件；有日期的 Markdown 标题 → 日记；其余 → 对话。印象默认 heat=1，其余为 2。自定义来源已有明确分类时保留原分类，日期日记优先。**导入的分类是启发式猜测，可能分错，可以在管理面板手动编辑。** 过滤和分类都不调用 LLM。
@@ -373,3 +420,4 @@ node --test test/*.test.mjs
 ## 许可
 
 MIT。可以商用、可以修改、可以再发布，保留版权声明即可（见 [LICENSE](./LICENSE)）。
+

package/lib/auto-import.js

@@ -2,16 +2,90 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createHash, randomBytes } from 'node:crypto';
 import { readConfig } from './config.js';
+import { onConfigUpdate } from './config-write.js';
 import { inferEmotion } from './decay.js';
 import { findDuplicate, prepare } from './dedupe.js';
 import { parseTime } from './import.js';
 import { eventText, usefulText } from './session-text.js';
 import { parseSourceFile, readJsonl, sourceFiles, verifySource } from './auto-sources.js';
 import { backupForAutomation, readState, service, warningLogger, writeState } from './automation-state.js';
-import { isNoise } from './noise.js';
+import { isInjected, isNoise, isWorkRecord, workMatches } from './noise.js';
 import { classifyImport } from './classify.js';
+import { assessSession, normalizeSessionFilter, sessionFilterKey } from './session-filter.js';
 
 const digest = text => createHash('sha256').update(text).digest('hex');
+const day = 86400000;
+
+export function importMinChars(value = 12) {
+  if (!Number.isSafeInteger(value) || value < 4 || value > 200) throw new Error('autoImport.minChars 必须是 4～200 的整数');
+  return value;
+}
+
+const longPrefix = text => Array.from(text).length >= 50 ? Array.from(text).slice(0, 50).join('') : null;
+
+export function overlapsPersona(text, persona) {
+  if (typeof persona !== 'string' || Array.from(text).length < 100) return false;
+  const content = text.replace(/\s+/gu, '');
+  const reference = persona.replace(/\s+/gu, '');
+  const characters = Array.from(content);
+  if (characters.length < 100) return false;
+  let matches = 0;
+  let checked = 0;
+  for (let offset = 0; offset + 50 <= characters.length; offset += 50) {
+    checked++;
+    if (reference.includes(characters.slice(offset, offset + 50).join(''))) matches++;
+  }
+  return checked > 0 && matches / checked >= 0.6;
+}
+
+export function normalizeLedgerPolicy(settings = {}) {
+  const retention = settings.ledgerRetentionDays === undefined ? {} : settings.ledgerRetentionDays;
+  if (!retention || typeof retention !== 'object' || Array.isArray(retention)) throw new Error('ledgerRetentionDays 必须是对象');
+  for (const key of Object.keys(retention)) if (!['skip', 'session'].includes(key)) throw new Error(`ledgerRetentionDays 不支持 ${key}`);
+  const policy = { skip: retention.skip === undefined ? 30 : retention.skip, session: retention.session === undefined ? 120 : retention.session,
+    maximum: settings.ledgerMaxEntries === undefined ? 2000 : settings.ledgerMaxEntries };
+  for (const [key, minimum, maximum] of [['skip', 30, 36500], ['session', 120, 36500], ['maximum', 1, 100000]]) {
+    if (!Number.isSafeInteger(policy[key]) || policy[key] < minimum || policy[key] > maximum) throw new Error(`账本 ${key} 必须为 ${minimum}～${maximum} 的整数`);
+  }
+  return policy;
+}
+
+export function cleanupLedger(ledger, settings = {}, now = Date.now()) {
+  const policy = normalizeLedgerPolicy(settings);
+  const result = { expired: 0, expiredSkipCaches: 0, evicted: 0, before: Object.keys(ledger).length, after: 0, overLimit: false };
+  const candidates = [];
+  for (const [key, entry] of Object.entries(ledger)) {
+    if (!key.startsWith('session:') || !entry || typeof entry !== 'object' || entry.pending || entry.rescan) continue;
+    const watermark = Number.isSafeInteger(entry.lastSeq) && entry.lastSeq >= 0;
+    const updated = entry.skip && !watermark ? entry.skip.at : entry.importedAt;
+    if (!Number.isFinite(updated) || updated < 0) continue;
+    const lifetime = entry.skip && !watermark ? policy.skip : policy.session;
+    if (now - updated > lifetime * day) {
+      delete ledger[key];
+      result.expired++;
+      continue;
+    }
+    if (watermark && entry.skip && Number.isFinite(entry.skip.at) && now - entry.skip.at > policy.skip * day) {
+      delete entry.skip;
+      result.expiredSkipCaches++;
+    }
+    if (entry.skip && !watermark) candidates.push({ key, updated });
+  }
+  let remaining = Object.keys(ledger).length;
+  if (remaining > policy.maximum) {
+    const target = Math.max(1, Math.floor(policy.maximum * 0.75));
+    candidates.sort((left, right) => left.updated - right.updated || left.key.localeCompare(right.key));
+    for (const entry of candidates) {
+      if (remaining <= target) break;
+      delete ledger[entry.key];
+      remaining--;
+      result.evicted++;
+    }
+  }
+  result.after = remaining;
+  result.overLimit = remaining > policy.maximum;
+  return result;
+}
 
 export function createAutoImport({ ctx, store, now = Date.now, warn = () => {}, getConfig,
   sleep = milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds)), startupDelayMs = 8000, schedule = true } = {}) {
@@ -27,6 +101,7 @@ export function createAutoImport({ ctx, store, now = Date.now, warn = () => {},
   async function perform() {
     const settings = config();
     if (stopped || !settings.autoImport.enabled) return { added: 0, skipped: 0, processed: 0 };
+    const ledgerPolicy = normalizeLedgerPolicy(settings.autoImport);
     const ledger = readState(ledgerFile, {});
     if (!ledger || typeof ledger !== 'object' || Array.isArray(ledger)) throw new Error('import-ledger.json 必须是对象');
     const request = settings.autoImport.rescanAll ? 'all' : settings.autoImport.rescanFrom?.trim();
@@ -45,22 +120,43 @@ export function createAutoImport({ ctx, store, now = Date.now, warn = () => {},
       }
       consumedRescan = request;
     }
-    const totals = { added: 0, skipped: 0, processed: 0, noise: 0, assistant: 0 };
+    const totals = { added: 0, skipped: 0, processed: 0, noise: 0, assistant: 0, work: 0,
+      sessionsSkipped: 0, workSessions: 0, cachedSessions: 0 };
     const maximum = settings.autoImport.maxPerRun;
+    const minimum = importMinChars(settings.autoImport.minChars);
+    let persona = null;
+    if (settings.personaFile) {
+      try { persona = await fs.readFile(settings.personaFile, 'utf8'); }
+      catch (error) { warning(`无法读取角色卡 ${settings.personaFile}：${error.message}`, { once: true }); }
+    }
     const patterns = settings.autoMemory.excludePatterns;
+    const allowAssistant = () => settings.autoImport.importAssistant === true && config().autoImport.importAssistant === true;
+    const sessionFilter = normalizeSessionFilter(settings.autoImport.sessionFilter);
+    const skippedTools = new Set();
 
     function commit(entries, key, cursor) {
       if (stopped) return;
       if (entries.length) {
         const rows = store.read();
         const prepared = rows.map(row => prepare(row.text));
+        const prefixes = new Set(rows.map(row => longPrefix(row.text)).filter(Boolean));
         let added = 0;
         for (const candidate of entries) {
+          if (candidate.origin?.source === 'dsh-sessions' && candidate.origin.role !== 'user' && !allowAssistant()) {
+            totals.assistant++; totals.skipped++; continue;
+          }
+          if (isInjected(candidate.text)) { totals.noise++; totals.skipped++; continue; }
+          if (candidate.origin?.source === 'dsh-sessions' && Array.from(candidate.text).length < minimum) { totals.skipped++; continue; }
+          if (candidate.origin?.source === 'dsh-sessions' && overlapsPersona(candidate.text, persona)) { totals.skipped++; continue; }
           if (isNoise(candidate.text, settings.autoImport.noisePatterns)) { totals.noise++; totals.skipped++; continue; }
+          if (isWorkRecord(candidate.text, settings.autoImport.workMarkers)) { totals.work++; totals.skipped++; continue; }
+          const prefix = longPrefix(candidate.text);
+          if (prefix && prefixes.has(prefix)) { totals.skipped++; continue; }
           if (findDuplicate(rows, candidate, prepared, 0.85)) { totals.skipped++; continue; }
           const { category: _category, ...fields } = candidate;
           rows.push({ ...fields, id: `m-${now()}-${randomBytes(3).toString('hex')}`, createdAt: now() });
           prepared.push(prepare(candidate.text));
+          if (prefix) prefixes.add(prefix);
           added++;
         }
         if (added) {
@@ -74,17 +170,51 @@ export function createAutoImport({ ctx, store, now = Date.now, warn = () => {},
       writeState(ledgerFile, ledger);
     }
 
-    async function importSession(query, id) {
+    async function importSession(query, session) {
+      const id = session.header.id;
       const key = `session:${id}`;
       const saved = ledger[key] ?? { lastSeq: -1 };
       if (!Number.isSafeInteger(saved.lastSeq) || saved.lastSeq < -1) throw new Error(`${key} 水位无效`);
+      const policy = sessionFilterKey(session.header, sessionFilter);
+      function skipped(reason, cached = false) {
+        totals.sessionsSkipped++;
+        if (cached) totals.cachedSessions++;
+        if (reason.reason === 'work-tools') {
+          totals.workSessions++;
+          for (const name of reason.tools) skippedTools.add(name);
+        }
+      }
+      if (saved.skip?.cacheable && saved.skip.policy === policy && !saved.rescan) { skipped(saved.skip, true); return; }
       const read = await query.readSession(id);
       if (stopped) return;
       if (!Array.isArray(read?.events)) throw new Error('readSession 未返回 events 数组');
+      let decision = assessSession({ ...read.session, ...session.header }, read.events, sessionFilter);
+      if (decision.accepted && sessionFilter.mode === 'auto') {
+        const cwd = session.header.cwd ?? read.session?.cwd;
+        if (typeof cwd === 'string' && cwd.trim()) {
+          let workingDirectory = /(^|[\\/])default-workspace([\\/]|$)/iu.test(cwd);
+          if (!workingDirectory) {
+            try { workingDirectory = (await fs.stat(path.join(cwd, 'package.json'))).isFile(); }
+            catch {}
+          }
+          if (workingDirectory && read.events.some(event => event.type === 'user/message'
+            && workMatches(eventText(event), settings.autoImport.workMarkers).length >= 2)) {
+            decision = { accepted: false, reason: 'work-message', cacheable: true };
+          }
+        }
+      }
+      if (!decision.accepted) {
+        skipped(decision);
+        ledger[key] = { ...saved, skip: { ...decision, sessionId: id, mode: sessionFilter.mode, policy, at: now() } };
+        delete ledger[key].rescan;
+        writeState(ledgerFile, ledger);
+        return;
+      }
       let cursor = { ...saved };
+      delete cursor.skip;
       let batch = [];
       let processed = 0;
-      let dirty = false;
+      let dirty = !!saved.skip;
       let scanned = 0;
       async function flush() {
         if (dirty) commit(batch, key, cursor);
@@ -96,19 +226,24 @@ export function createAutoImport({ ctx, store, now = Date.now, warn = () => {},
         if (stopped) return;
         if (++scanned % 200 === 0) await sleep(20);
         if (!Number.isSafeInteger(event.seq) || event.seq <= cursor.lastSeq) continue;
-        if (event.type === 'assistant/message' && settings.autoImport.importAssistant !== true) {
+        const role = event.type === 'user/message' ? 'user' : event.type === 'assistant/message' ? 'assistant' : null;
+        if (!role || role === 'assistant' && !allowAssistant()) {
           cursor.lastSeq = event.seq;
           delete cursor.pending;
           dirty = true;
-          totals.assistant++;
+          if (role === 'assistant') totals.assistant++;
           continue;
         }
         const text = eventText(event);
         const hash = text ? digest(text) : null;
         const timestamp = parseTime(event.time);
         const noise = isNoise(text, settings.autoImport.noisePatterns);
+        const work = isWorkRecord(text, settings.autoImport.workMarkers);
+        const injected = isInjected(text);
         if (noise) totals.noise++;
-        if (!text || !usefulText(text) || noise || timestamp === null || hash === cursor.lastTextHash || patterns.some(pattern => text.includes(pattern))) {
+        if (work) totals.work++;
+        if (!text || injected || Array.from(text).length < minimum || overlapsPersona(text, persona)
+          || !usefulText(text) || noise || work || timestamp === null || hash === cursor.lastTextHash || patterns.some(pattern => text.includes(pattern))) {
           cursor.lastSeq = event.seq;
           delete cursor.pending;
           if (hash) cursor.lastTextHash = hash;
@@ -122,7 +257,7 @@ export function createAutoImport({ ctx, store, now = Date.now, warn = () => {},
           const part = characters.slice(offset, offset + 2000).join('');
           const inferred = inferEmotion(part);
           batch.push({ text: part, ...classifyImport(text), ts: timestamp, emotion: inferred.emotion, boosts: 0,
-            origin: { source: 'dsh-sessions', sessionId: id, seq: event.seq, offset, role: event.type === 'user/message' ? 'user' : 'assistant' } });
+            origin: { source: 'dsh-sessions', sessionId: id, seq: event.seq, offset, role } });
           processed++;
           offset += 2000;
           if (offset >= characters.length) {
@@ -186,7 +321,7 @@ export function createAutoImport({ ctx, store, now = Date.now, warn = () => {},
           for (const session of prioritized) {
             if (stopped || totals.processed >= maximum) break;
             if (typeof session.header?.id !== 'string') continue;
-            try { await importSession(query, session.header.id); }
+            try { await importSession(query, session); }
             catch (error) { warning(`导入会话 ${session.header.id} 失败：${error.message}`); }
           }
         } else {
@@ -199,6 +334,20 @@ export function createAutoImport({ ctx, store, now = Date.now, warn = () => {},
         }
       } catch (error) { warning(`略过来源 ${source.path ?? source.type}：${error.message}`, { once: true }); }
     }
+    if (totals.workSessions) {
+      try { warn(`跳过 ${totals.workSessions} 个工作会话（原因：用过 ${[...skippedTools].join('/')}；账本跳过 ${totals.cachedSessions} 个会话）`); } catch {}
+    }
+    if (!stopped) {
+      const cleaned = cleanupLedger(ledger, settings.autoImport, now());
+      if (cleaned.expired || cleaned.expiredSkipCaches || cleaned.evicted) {
+        writeState(ledgerFile, ledger);
+        try { warn(`清理账本：删除 ${cleaned.expired} 条过期记录（skip ${ledgerPolicy.skip} 天 / session ${ledgerPolicy.session} 天），清除 ${cleaned.expiredSkipCaches} 条过期 skip 缓存，超限淘汰 ${cleaned.evicted} 条无水位缓存（${cleaned.before} → ${cleaned.after}）`); } catch {}
+      }
+      if (cleaned.overLimit) {
+        try { warn(`账本仍有 ${cleaned.after} 条，超过上限 ${ledgerPolicy.maximum}；保留近期水位、文件进度和未完成任务，未强制删除`); } catch {}
+      }
+      totals.ledgerCleanup = cleaned;
+    }
     return totals;
   }
 
@@ -222,6 +371,9 @@ export function createAutoImport({ ctx, store, now = Date.now, warn = () => {},
     }, delay);
     timer.unref?.();
   }
+  const removeConfigListener = onConfigUpdate(home, changes => {
+    if (changes.autoImport?.sessionFilter?.mode) void (running ? running.finally(() => runNow()) : runNow());
+  });
   if (schedule) next(startupDelayMs);
-  return { runNow, dispose() { stopped = true; clearTimeout(timer); } };
+  return { runNow, dispose() { stopped = true; clearTimeout(timer); removeConfigListener(); } };
 }

package/lib/automation-config.js

@@ -1,7 +1,17 @@
+import { assessSession, normalizeSessionFilter } from './session-filter.js';
+import { normalizeWorkMarkers } from './noise.js';
+
 export const memoryDefaults = Object.freeze({ enabled: false, provider: 'deepseek-account', model: 'deepseek-flash',
   maxPerTurn: 2, minChars: 12, dailyCap: 40, cooldownSec: 30,
   excludePatterns: Object.freeze(['密码', '身份证', '银行卡', '手机号', '验证码']) });
 
+export function sessionImportHint(autoImport, sessions) {
+  if (!Array.isArray(sessions) || !autoImport.enabled || autoImport.sessionFilter.mode !== 'include'
+    || !autoImport.sources.some(source => source.type === 'dsh-sessions')) return null;
+  if (sessions.some(session => assessSession(session.header ?? session, [], autoImport.sessionFilter).accepted)) return null;
+  return { hint: 'no-session-matched', message: '没有会话命中来源白名单，导入可能全部被跳过。请检查 sessionFilter 配置' };
+}
+
 function object(value, name) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${name} 必须是对象`);
 }
@@ -19,7 +29,7 @@ export function automationConfig(config = {}, warn = () => {}) {
   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,
+  let autoImport = { enabled: true, importAssistant: false, noisePatterns: [], workMarkers: [], sessionFilter: normalizeSessionFilter(), rescanAll: false,
     sources, intervalMinutes: 60, maxPerRun: 200 };
   try {
     if (config.autoMemory !== undefined) object(config.autoMemory, 'autoMemory');
@@ -47,6 +57,8 @@ export function automationConfig(config = {}, warn = () => {}) {
     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 必须是非空字符串数组');
+    autoImport.workMarkers = normalizeWorkMarkers(autoImport.workMarkers);
+    autoImport.sessionFilter = normalizeSessionFilter(autoImport.sessionFilter);
     range(autoImport.intervalMinutes, 'intervalMinutes', 1, 10080);
     range(autoImport.maxPerRun, 'maxPerRun', 1, 10000);
     if (!Array.isArray(autoImport.sources)) throw new Error('sources 必须是数组');
@@ -59,8 +71,9 @@ export function automationConfig(config = {}, warn = () => {}) {
     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,
+    autoImport = { enabled: false, importAssistant: false, noisePatterns: [], workMarkers: [], sessionFilter: normalizeSessionFilter(), rescanAll: false,
       sources: [], intervalMinutes: 60, maxPerRun: 200 };
   }
   return { autoMemory, autoImport };
 }
+

package/lib/client.js

@@ -899,6 +899,11 @@ function frame(now) {
       return React.createElement("section", { "aria-label": "记忆设置", "data-memory-engine-settings": "true",
         style: { position: "absolute", inset: "76px 0 0", overflowY: "auto", padding: "0 24px 32px", color: "#dbeaf8", font: "14px/1.7 system-ui,sans-serif" } },
         React.createElement("div", { style: { maxWidth: "900px", margin: "0 auto", padding: "28px", border: "1px solid #263f54", borderRadius: "14px", background: "#0b1624" } },
+          props.settings.autoImport?.hint === "no-session-matched" ? React.createElement("div", { role: "alert", "data-memory-engine-import-hint": "true",
+            style: { marginBottom: "20px", padding: "12px 16px", border: "1px solid #9c7243", borderRadius: "8px", background: "#2a2118", color: "#ffe1ac" } },
+            React.createElement("span", null, props.settings.autoImport.message), " ",
+            React.createElement("button", { type: "button", "data-memory-engine-use-auto-import": "true", disabled: props.configBusy,
+              onClick: props.onUseAutoImport, style: actionStyle }, "改用宽松模式")) : null,
           React.createElement("section", { style: { marginBottom: "24px", paddingBottom: "20px", borderBottom: "1px solid #263f54" } },
             React.createElement("h2", { style: { margin: "0 0 12px", fontSize: "20px", color: "#b7e9ff" } }, "自动记忆"),
             React.createElement(AutoMemoryToggle, { settings: props.settings, busy: props.configBusy, onToggle: props.onToggle, location: "settings" }),
@@ -1000,6 +1005,19 @@ function frame(now) {
         if (!enabled && settings.showAutoMemoryCostHint !== false) setCostHint(true);
         else saveAutoMemory(!enabled);
       }
+      function useAutoImport() {
+        if (configBusy || configRequest.current) return;
+        var controller = new AbortController();
+        var timer = setTimeout(function () { controller.abort(); }, 10000);
+        configRequest.current = controller;
+        setConfigBusy(true); setConfigError("");
+        requestApi("/memory-engine/api/config", { method: "PUT", headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ autoImport: { sessionFilter: { mode: "auto" } } }), signal: controller.signal }).then(function (data) {
+            setSettings(Object.assign({}, defaultSettings, data));
+          }).catch(function (failure) {
+            setConfigError("保存失败：" + (controller.signal.aborted ? "请求超时或已中断，请刷新确认状态" : failure.message));
+          }).finally(function () { clearTimeout(timer); configRequest.current = null; setConfigBusy(false); });
+      }
       function closeGuide() {
         dismissed.current = true;
         setGuideOpen(false);
@@ -1076,7 +1094,7 @@ function frame(now) {
         style: { position: "fixed", inset: 0, maxWidth: "none", maxHeight: "none", zIndex: 9999, background: "#03060c" },
       }, tab === "map" ? React.createElement(MemoryCanvas, { key: open, rendererRef: renderer, selectionVersion: selectionVersion, onSelect: setSelected })
         : tab === "memories" ? React.createElement(MemoryList, { onChanged: function () { setRetry(function (value) { return value + 1; }); } })
-          : React.createElement(MemorySettings, { settings: settings, configBusy: configBusy, onToggle: toggleAutoMemory,
+          : React.createElement(MemorySettings, { settings: settings, configBusy: configBusy, onToggle: toggleAutoMemory, onUseAutoImport: useAutoImport,
             onCleared: function () { openMap(); setGuideOpen(true); } }),
       tab !== "map" ? React.createElement("strong", { style: { position: "absolute", top: "23px", left: "24px", font: "600 18px system-ui,sans-serif", color: "#b7e9ff" } }, "记忆管理") : null,
       React.createElement("style", null, "@keyframes dsh-memory-detail-in{from{opacity:0;transform:translateX(24px)}to{opacity:1;transform:translateX(0)}}@media(prefers-reduced-motion:reduce){[data-memory-engine-detail]{animation:none!important}}"),

package/lib/client.src.js

@@ -511,6 +511,11 @@ window.__ModuleLoader__.load({
       return React.createElement("section", { "aria-label": "记忆设置", "data-memory-engine-settings": "true",
         style: { position: "absolute", inset: "76px 0 0", overflowY: "auto", padding: "0 24px 32px", color: "#dbeaf8", font: "14px/1.7 system-ui,sans-serif" } },
         React.createElement("div", { style: { maxWidth: "900px", margin: "0 auto", padding: "28px", border: "1px solid #263f54", borderRadius: "14px", background: "#0b1624" } },
+          props.settings.autoImport?.hint === "no-session-matched" ? React.createElement("div", { role: "alert", "data-memory-engine-import-hint": "true",
+            style: { marginBottom: "20px", padding: "12px 16px", border: "1px solid #9c7243", borderRadius: "8px", background: "#2a2118", color: "#ffe1ac" } },
+            React.createElement("span", null, props.settings.autoImport.message), " ",
+            React.createElement("button", { type: "button", "data-memory-engine-use-auto-import": "true", disabled: props.configBusy,
+              onClick: props.onUseAutoImport, style: actionStyle }, "改用宽松模式")) : null,
           React.createElement("section", { style: { marginBottom: "24px", paddingBottom: "20px", borderBottom: "1px solid #263f54" } },
             React.createElement("h2", { style: { margin: "0 0 12px", fontSize: "20px", color: "#b7e9ff" } }, "自动记忆"),
             React.createElement(AutoMemoryToggle, { settings: props.settings, busy: props.configBusy, onToggle: props.onToggle, location: "settings" }),
@@ -612,6 +617,19 @@ window.__ModuleLoader__.load({
         if (!enabled && settings.showAutoMemoryCostHint !== false) setCostHint(true);
         else saveAutoMemory(!enabled);
       }
+      function useAutoImport() {
+        if (configBusy || configRequest.current) return;
+        var controller = new AbortController();
+        var timer = setTimeout(function () { controller.abort(); }, 10000);
+        configRequest.current = controller;
+        setConfigBusy(true); setConfigError("");
+        requestApi("/memory-engine/api/config", { method: "PUT", headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ autoImport: { sessionFilter: { mode: "auto" } } }), signal: controller.signal }).then(function (data) {
+            setSettings(Object.assign({}, defaultSettings, data));
+          }).catch(function (failure) {
+            setConfigError("保存失败：" + (controller.signal.aborted ? "请求超时或已中断，请刷新确认状态" : failure.message));
+          }).finally(function () { clearTimeout(timer); configRequest.current = null; setConfigBusy(false); });
+      }
       function closeGuide() {
         dismissed.current = true;
         setGuideOpen(false);
@@ -688,7 +706,7 @@ window.__ModuleLoader__.load({
         style: { position: "fixed", inset: 0, maxWidth: "none", maxHeight: "none", zIndex: 9999, background: "#03060c" },
       }, tab === "map" ? React.createElement(MemoryCanvas, { key: open, rendererRef: renderer, selectionVersion: selectionVersion, onSelect: setSelected })
         : tab === "memories" ? React.createElement(MemoryList, { onChanged: function () { setRetry(function (value) { return value + 1; }); } })
-          : React.createElement(MemorySettings, { settings: settings, configBusy: configBusy, onToggle: toggleAutoMemory,
+          : React.createElement(MemorySettings, { settings: settings, configBusy: configBusy, onToggle: toggleAutoMemory, onUseAutoImport: useAutoImport,
             onCleared: function () { openMap(); setGuideOpen(true); } }),
       tab !== "map" ? React.createElement("strong", { style: { position: "absolute", top: "23px", left: "24px", font: "600 18px system-ui,sans-serif", color: "#b7e9ff" } }, "记忆管理") : null,
       React.createElement("style", null, "@keyframes dsh-memory-detail-in{from{opacity:0;transform:translateX(24px)}to{opacity:1;transform:translateX(0)}}@media(prefers-reduced-motion:reduce){[data-memory-engine-detail]{animation:none!important}}"),

package/lib/config-write.js

@@ -2,11 +2,16 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { readState, writeState } from './automation-state.js';
 import { readUiConfig } from './config.js';
+import { normalizeSessionFilter } from './session-filter.js';
+import { normalizeWorkMarkers } from './noise.js';
 
 const listeners = new Map();
 const writable = new Map([
   ['autoMemory.enabled', value => typeof value === 'boolean'],
   ['autoImport.enabled', value => typeof value === 'boolean'],
+  ['autoImport.importAssistant', value => typeof value === 'boolean'],
+  ['autoImport.workMarkers', value => { normalizeWorkMarkers(value); return true; }],
+  ['autoImport.sessionFilter', value => { normalizeSessionFilter(value); return true; }],
   ['autoMemory.maxPerTurn', value => Number.isSafeInteger(value) && value >= 1 && value <= 5],
   ['autoMemory.dailyCap', value => Number.isSafeInteger(value) && value >= 0 && value <= 500],
   ['spinSpeed', value => Number.isFinite(value) && value >= 0.05 && value <= 1.5],
@@ -37,7 +42,9 @@ export function updateConfig(home, changes, { now = Date.now, warn = () => {} }
   if (!fields.length) invalid('至少提供一个可修改字段');
   for (const [key, value] of fields) {
     if (!writable.has(key) || Object.hasOwn(changes, key) && key.includes('.')) invalid(`不支持修改 ${key}`);
-    if (!writable.get(key)(value)) invalid(`${key} 类型或范围错误`);
+    try {
+      if (!writable.get(key)(value)) invalid(`${key} 类型或范围错误`);
+    } catch (error) { invalid(error.message); }
   }
   const directory = path.join(home, 'memory-engine');
   const file = path.join(directory, 'config.json');
@@ -48,6 +55,10 @@ export function updateConfig(home, changes, { now = Date.now, warn = () => {} }
     if (key === 'autoMemory' || key === 'autoImport') next[key] = { ...current[key], ...changes[key] };
     else next[key] = changes[key];
   }
+  if (changes.autoImport?.sessionFilter) {
+    try { next.autoImport.sessionFilter = normalizeSessionFilter({ ...current.autoImport?.sessionFilter, ...changes.autoImport.sessionFilter }); }
+    catch (error) { invalid(error.message); }
+  }
   if (changes.autoMemory?.enabled === true) next.showAutoMemoryCostHint = false;
   fs.mkdirSync(directory, { recursive: true });
   const prefix = `config.json.bak-${now()}`;

package/lib/index.js

@@ -200,7 +200,8 @@ export function apply(ctx) {
         const store = new MemoryStore();
         for (const tool of createTools(defineTool, store, { warning: message => warn(ctx, message) })) disposers.push(ctx.tools.register(tool));
         try {
-          disposers.push(registerMemoryRoutes(ctx.webServer, { store, warn: message => warn(ctx, message) }));
+          disposers.push(registerMemoryRoutes(ctx.webServer, { store, warn: message => warn(ctx, message),
+            listSessions: () => ctx.get('sessionQuery')?.listSessions() }));
         } catch (error) {
           warn(ctx, `图谱路由注册失败，记忆工具仍可用：${error.message}`);
         }

package/lib/noise.js

@@ -7,8 +7,55 @@ export const DEFAULT_NOISE_PATTERNS = Object.freeze([
 
 const REPORT_PREFIX = /^\s*(已回|已回复|已发送|已处理|已确认|已读|已标记|回过了|发过了)\s*[:：]/u;
 
+const INJECTED = Object.freeze([
+  /^下面是我和他?刚才的聊天记录/u,
+  /每行「谁：说了什么」/u,
+  /^Current runtime context\. This snapshot supersedes/im,
+  /<message\s+source_id=/u,
+  /^【会话令牌】/mu,
+  /^\s*##\s*(Runtime|Context)\b/im,
+]);
+
+export function isInjected(text) {
+  return typeof text === 'string' && INJECTED.some(pattern => pattern.test(text));
+}
+
+export const WORK_MARKERS = Object.freeze([
+  /memory_(save|recall|forget|dedupe|import|map|stats)/iu,
+  /hideButton|showGuideOnEmpty|personaFile|autoImport|autoMemory|spinSpeed/iu,
+  /验收|任务书|里程碑|回归测试|测试全绿/u,
+  /pnpm|\bnpm\b|commit|git push|构建|编译|部署|重启\s*DSH/iu,
+  /版本号|0\.\d+\.\d+|beta\.\d/iu,
+  /录屏|截图|演示库|演示服务器/u,
+]);
+
+export function normalizeWorkMarkers(value = []) {
+  if (!Array.isArray(value) || value.length > 20
+    || value.some(pattern => typeof pattern !== 'string' || !pattern.trim() || pattern.length > 300)) throw new Error('workMarkers 必须是最多 20 个非空正则表达式字符串');
+  for (const pattern of value) new RegExp(pattern, 'iu');
+  return [...value];
+}
+
+export function workMatches(text, extra = []) {
+  if (typeof text !== 'string') return [];
+  const patterns = [...WORK_MARKERS, ...extra.map(pattern => new RegExp(pattern, 'iu'))];
+  const seen = new Set();
+  return patterns.filter(pattern => {
+    if (seen.has(pattern.source)) return false;
+    seen.add(pattern.source);
+    return pattern.test(text);
+  }).map(pattern => pattern.source);
+}
+
+export function isWorkRecord(text, extra = []) {
+  const matches = workMatches(text, extra);
+  const releaseOnly = matches.length === 2 && matches.includes(WORK_MARKERS[3].source) && matches.includes(WORK_MARKERS[4].source);
+  return matches.length >= 2 && !releaseOnly;
+}
+
 export function isNoise(text, extra = []) {
   if (typeof text !== 'string') return false;
+  if (isInjected(text)) return true;
   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));

package/lib/onboard.js

@@ -1,4 +1,11 @@
+// 引导文案（0.7.0）：先说自动记忆，再说手动的路
+// 原则：看到「三条」就知道该干什么，不需要读文档。
+
+// 可选的手动提示词：自动记忆关闭时才需要它。
+// 不要再把它说成「必须加进角色卡」——0.7.0 起自动记忆能自己抽。
 export const ONBOARD_PROMPT = [
+  '（自动记忆已开启时可以不用这一段）',
+  '',
   '聊天时遇到这些，用 memory_save 记下来：',
   '  · 对方的称呼、偏好、忌讳、习惯（kind="印象"，who 填对方名字）',
   '  · 答应过的事、约定、承诺（kind="对话"）',
@@ -11,8 +18,16 @@ export const ONBOARD_PROMPT = [
 ].join('\n');
 
 export const ONBOARD_STEPS = [
-  { title: '让机器人开始记', body: '把这段提示词加进机器人的角色卡或提示词里。' },
-  { title: '或者导入旧记忆', body: '在对话里说：「把 D:\\bot\\memories.json 导进记忆库」。支持 JSON、Markdown 和纯文本，先预览，确认后导入。' },
-  { title: '聊几句，回来点刷新', body: '有了新记忆后，点「刷新图谱」就能看到。' },
+  {
+    title: '先打开自动记忆',
+    body: '图谱右上角有个「自动记忆」开关，默认是关的。点一下变成 ● 之后，每轮对话结束会自动抽 0~2 条记下来——这时候你什么都不用做。会调用模型，大约每轮几分钱，随时可以再点掉。',
+  },
+  {
+    title: '想把旧记录也收进来',
+    body: '跟 AI 说「把 D:\\bot\\memories.json 导进记忆库」，它会调 memory_import。支持 JSON、Markdown、纯文本和 DSH 会话记录；默认只预览，确认后才写入。',
+  },
+  {
+    title: '回来这里看',
+    body: '「记忆」页签能搜索、改错字、删除、导出；「图谱」页签是所有记忆画成的球体，中间那颗金色的是你的人设卡（在 config.json 里配 personaFile）。拖拽旋转，点任意光点看它连着什么。数据存在本机 ~/.dsh/memory-engine/，纯 JSON 明文，不会上传到任何地方。',
+  },
 ];
-

package/lib/routes.js

@@ -2,8 +2,9 @@ import path from 'node:path';
 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 { readConfig, readUiConfig } from './config.js';
 import { updateConfig } from './config-write.js';
+import { sessionImportHint } from './automation-config.js';
 import { chars, retention, titleOf } from './decay.js';
 import { scoreMemories } from './render/score.mjs';
 
@@ -75,7 +76,19 @@ function listMemories(store, query) {
     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 = () => {}, beforeConfigUpdate = () => {} }) {
+export function createMemoryHandler({ store, warn = () => {}, beforeConfigUpdate = () => {}, listSessions }) {
+  const home = path.dirname(path.dirname(store.file));
+  async function withSessionHint(data) {
+    if (typeof listSessions !== 'function') return data;
+    try {
+      const sessions = await listSessions();
+      const hint = sessionImportHint(readConfig(home).autoImport, sessions);
+      return hint ? { ...data, autoImport: { ...data.autoImport, ...hint } } : data;
+    } catch (error) {
+      warn(`读取会话来源提示失败：${error.message}`);
+      return data;
+    }
+  }
   return async (request, response) => {
     let methods = ['GET'];
     const reply = (status, payload, html = false) => {
@@ -107,7 +120,8 @@ export function createMemoryHandler({ store, warn = () => {}, beforeConfigUpdate
         const body = await readBody(request);
         if (pathname === `${base}/api/config`) {
           beforeConfigUpdate(body);
-          return reply(200, { ok: true, data: updateConfig(path.dirname(path.dirname(store.file)), body, { warn }) });
+          const data = updateConfig(home, body, { warn });
+          return reply(200, { ok: true, data: await withSessionHint(data) });
         }
         return reply(200, { ok: true, data: item ? store.updateItem(item[1], body) : store.clear(body) });
       }
@@ -125,7 +139,7 @@ export function createMemoryHandler({ store, warn = () => {}, beforeConfigUpdate
       }
       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)), { warn }) });
+      if (pathname === `${base}/api/config`) return reply(200, { ok: true, data: await withSessionHint(readUiConfig(home, { 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),
       } });

package/lib/session-filter.js

@@ -0,0 +1,47 @@
+export const CHAT_CWD_HINTS = Object.freeze(['state/agents', 'qq-bridge', 'astrbot', 'nonebot', 'koishi']);
+export const sessionFilterDefaults = Object.freeze({ mode: 'include', cwdContains: CHAT_CWD_HINTS, maxToolCalls: 0 });
+const workTool = /(?:^|[./:]|__)(pwsh|bash|read|write|edit|grep|glob|subagent|workflow|notebook)$/iu;
+const normalizePath = value => String(value ?? '').replaceAll('\\', '/').toLowerCase();
+const matchCwd = (cwd, part) => {
+  const normalizedCwd = normalizePath(cwd);
+  const normalizedPart = normalizePath(part).replace(/^\/+|\/+$/gu, '');
+  if (!CHAT_CWD_HINTS.includes(normalizedPart)) return normalizedCwd.includes(normalizedPart);
+  return `/${normalizedCwd.replace(/^\/+|\/+$/gu, '')}/`.includes(`/${normalizedPart}/`);
+};
+
+export function normalizeSessionFilter(value = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('sessionFilter 必须是对象');
+  for (const key of Object.keys(value)) if (!Object.hasOwn(sessionFilterDefaults, key)) throw new Error(`sessionFilter 不支持 ${key}`);
+  const filter = { ...sessionFilterDefaults, ...value };
+  if (!['auto', 'include', 'all'].includes(filter.mode)) throw new Error('sessionFilter.mode 必须是 auto、include 或 all');
+  if (!Array.isArray(filter.cwdContains) || filter.cwdContains.length > 50
+    || filter.cwdContains.some(item => typeof item !== 'string' || !item.trim() || item.length > 1000)) throw new Error('cwdContains 必须是最多 50 个非空路径片段');
+  if (!Number.isSafeInteger(filter.maxToolCalls) || filter.maxToolCalls < 0 || filter.maxToolCalls > 10000) throw new Error('maxToolCalls 必须是 0～10000 的整数');
+  return { ...filter, cwdContains: filter.cwdContains.map(item => item.trim()) };
+}
+
+export function sessionFilterKey(header, filter) {
+  return JSON.stringify({ version: 2, filter, cwd: normalizePath(header?.cwd) });
+}
+
+export function assessSession(header, events, filter = sessionFilterDefaults) {
+  if (filter.mode === 'all') return { accepted: true };
+  if (filter.mode === 'include') {
+    return filter.cwdContains.some(part => matchCwd(header?.cwd, part)) ? { accepted: true }
+      : { accepted: false, reason: 'cwd-excluded', message: 'cwd 未命中包含列表', cacheable: true };
+  }
+  let userMessages = 0;
+  let workToolCalls = 0;
+  const tools = new Set();
+  for (const event of events) {
+    if (event.type === 'user/message' && (!event.data?.role || event.data.role === 'user')) userMessages++;
+    if (event.type === 'tool/call' && typeof event.data?.name === 'string' && workTool.test(event.data.name)) {
+      workToolCalls++;
+      tools.add(event.data.name);
+      if (workToolCalls > filter.maxToolCalls) return { accepted: false, reason: 'work-tools',
+        message: `用过 ${[...tools].join('/')}`, tools: [...tools], workToolCalls, userMessages, cacheable: true };
+    }
+  }
+  return userMessages >= 2 ? { accepted: true } : { accepted: false, reason: 'too-few-user-messages',
+    message: `user 消息不足 2 条（当前 ${userMessages} 条）`, userMessages, cacheable: false };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-engine",
-  "version": "0.7.0",
+  "version": "0.7.5",
   "description": "Local DSH memory engine with neuron network visualization and private file import",
   "keywords": [
     "dsh",
@@ -29,6 +29,7 @@
     "lib/",
     "scripts/render-map.mjs",
     "scripts/sync-qq.mjs",
+    "scripts/cleanup-imports.mjs",
     "scripts/build-client.mjs",
     "scripts/lib/",
     "cordis.patch.yml",

package/scripts/cleanup-imports.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { parseArgs } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import { MemoryStore } from '../lib/store.js';
+import { duplicateGroups } from '../lib/dedupe.js';
+import { isWorkRecord, normalizeWorkMarkers, workMatches } from '../lib/noise.js';
+import { readState } from '../lib/automation-state.js';
+
+const digest = value => createHash('sha256').update(value).digest('hex');
+const isQQ = row => ['qq-bridge', 'bridge'].includes(row.origin?.source);
+const qqCount = rows => rows.filter(isQQ).length;
+const fingerprint = file => digest(fs.existsSync(file) ? fs.readFileSync(file) : '[]');
+
+export function previewCleanup({ home, stage, threshold = 0.7, protectQQ = false }) {
+  if (!home) throw new Error('必须明确指定 home');
+  if (!['assistant', 'work', 'dedupe'].includes(stage)) throw new Error('stage 必须是 assistant、work 或 dedupe');
+  if (typeof protectQQ !== 'boolean' || protectQQ && stage !== 'dedupe') throw new Error('protectQQ 仅支持 dedupe 步骤的布尔开关');
+  const store = new MemoryStore({ home });
+  const beforeHash = fingerprint(store.file);
+  const rows = store.read();
+  const config = readState(path.join(path.dirname(store.file), 'config.json'), {});
+  const markers = normalizeWorkMarkers(config.autoImport?.workMarkers);
+  const assistants = rows.filter(row => !isQQ(row) && row.origin?.role === 'assistant');
+  const work = rows.filter(row => !isQQ(row) && isWorkRecord(row.text, markers));
+  if (stage !== 'assistant' && assistants.length) throw new Error(`请先完成 assistant 步骤（剩余 ${assistants.length} 条）`);
+  if (stage === 'dedupe' && work.length) throw new Error(`请先完成 work 步骤（剩余 ${work.length} 条）`);
+  let selected;
+  let protectedRows = [];
+  let groups = [];
+  let qqAfter = qqCount(rows);
+  if (stage === 'dedupe') {
+    const allGroups = duplicateGroups(rows, threshold);
+    const conflicts = protectQQ ? allGroups.filter(group => qqCount(group.indices.map(index => rows[index])) > Number(isQQ(group.memory))) : [];
+    const excluded = new Set(conflicts);
+    const matches = allGroups.filter(group => !excluded.has(group));
+    protectedRows = conflicts.flatMap(group => group.indices.map(index => rows[index]));
+    groups = matches.map(group => ({ keep: group.memory.id, ids: group.indices.map(index => rows[index].id), memory: group.memory }));
+    selected = matches.flatMap(group => group.indices.slice(1).map(index => rows[index]));
+    qqAfter -= matches.reduce((sum, group) => sum + qqCount(group.indices.map(index => rows[index])) - Number(isQQ(group.memory)), 0);
+  } else {
+    const matches = rows.filter(row => stage === 'assistant' ? row.origin?.role === 'assistant' : isWorkRecord(row.text, markers));
+    selected = matches.filter(row => !isQQ(row));
+    protectedRows = matches.filter(isQQ);
+  }
+  if (fingerprint(store.file) !== beforeHash) throw new Error('预览期间记忆库已变化，请重新预览');
+  const plan = { version: 1, stage, protectQQ, file: store.file, beforeHash, before: rows.length, after: rows.length - selected.length,
+    removed: selected.length, qqBefore: qqCount(rows), qqAfter, blocked: qqAfter < qqCount(rows),
+    threshold: stage === 'dedupe' ? threshold : null, workMarkers: markers,
+    items: selected.map(row => ({ id: row.id, text: row.text, origin: row.origin ?? null,
+      reason: stage === 'work' ? workMatches(row.text, markers) : [stage] })),
+    protected: protectedRows.map(row => ({ id: row.id, text: row.text, origin: row.origin })), groups };
+  return { ...plan, token: digest(JSON.stringify(plan)) };
+}
+
+export function applyCleanup({ home, preview, confirm }) {
+  if (!preview?.token || confirm !== preview.token) throw new Error('必须先审阅清单，再用该清单的 token 明确确认');
+  const current = previewCleanup({ home, stage: preview.stage, threshold: preview.threshold ?? 0.7, protectQQ: preview.protectQQ ?? false });
+  const { token, ...reviewed } = preview;
+  if (digest(JSON.stringify(reviewed)) !== token || current.token !== token) throw new Error('清单已修改、库已变化或规则已改变，请重新预览并确认');
+  if (current.blocked) throw new Error('本次合并会减少 QQ 来源数量，已拒绝执行；请先审阅冲突组');
+  const store = new MemoryStore({ home });
+  if (!current.removed) return { stage: current.stage, removed: 0, total: current.before, qqBefore: current.qqBefore, qqAfter: current.qqBefore };
+  let backup;
+  if (current.stage === 'dedupe') {
+    const protectedIds = new Set(current.protected.map(row => row.id));
+    const scoped = Object.create(store);
+    if (protectedIds.size) {
+      const original = store.read();
+      scoped.read = () => store.read().filter(row => !protectedIds.has(row.id));
+      scoped.write = merged => {
+        if (fingerprint(store.file) !== current.beforeHash) throw new Error('合并期间记忆库已变化，未写入；请重新预览');
+        const byId = new Map(merged.map(row => [row.id, row]));
+        store.write(original.flatMap(row => protectedIds.has(row.id) ? [row] : byId.has(row.id) ? [byId.get(row.id)] : []));
+      };
+    }
+    const result = scoped.dedupe({ threshold: current.threshold, dry_run: false });
+    backup = result.backup;
+  } else {
+    const rows = store.read();
+    const selected = new Set(current.items.map(row => row.id));
+    backup = store.backup();
+    if (fingerprint(store.file) !== current.beforeHash) throw new Error('备份期间记忆库已变化，未删除；请重新预览');
+    store.write(rows.filter(row => !selected.has(row.id)));
+  }
+  const after = store.read();
+  if (after.length !== current.after || qqCount(after) !== current.qqAfter) throw new Error(`写后校验不符，请检查并保留备份：${backup}`);
+  return { stage: current.stage, removed: current.removed, total: after.length, qqBefore: current.qqBefore, qqAfter: qqCount(after), backup };
+}
+
+function main() {
+  const { values } = parseArgs({ options: { home: { type: 'string' }, stage: { type: 'string' }, out: { type: 'string' },
+    preview: { type: 'string' }, confirm: { type: 'string' }, threshold: { type: 'string' }, 'protect-qq': { type: 'boolean' }, help: { type: 'boolean' } } });
+  if (values.help) {
+    console.log('预览：node scripts/cleanup-imports.mjs --home <DSH目录> --stage assistant|work|dedupe --out <清单.json>\n保护 QQ 冲突组：预览 dedupe 时加 --protect-qq\n执行：node scripts/cleanup-imports.mjs --home <DSH目录> --preview <清单.json> --confirm <清单token>\n逐步审阅并确认；执行前关闭 DSH，避免其他进程同时写库。');
+    return;
+  }
+  if (values.preview) {
+    if (values.stage || values.out || values.threshold || values['protect-qq']) throw new Error('执行时只接受 home、preview 和 confirm');
+    const preview = JSON.parse(fs.readFileSync(values.preview, 'utf8').replace(/^\uFEFF/u, ''));
+    console.log(JSON.stringify(applyCleanup({ home: values.home, preview, confirm: values.confirm }), null, 2));
+    return;
+  }
+  if (values.confirm) throw new Error('确认时必须指定 preview 文件');
+  const preview = previewCleanup({ home: values.home, stage: values.stage, threshold: values.threshold === undefined ? 0.7 : Number(values.threshold),
+    protectQQ: values['protect-qq'] ?? false });
+  if (values.out) fs.writeFileSync(values.out, JSON.stringify(preview, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+  console.log(`将${preview.stage === 'dedupe' ? '合并删除' : '删除'} ${preview.removed} 条；QQ 来源 ${preview.qqBefore} → ${preview.qqAfter}；保护保留 ${preview.protected.length} 条${preview.blocked ? '；禁止执行：QQ 数量会减少' : ''}`);
+  console.log(JSON.stringify({ token: preview.token, first10: preview.items.slice(0, 10) }, null, 2));
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  try { main(); } catch (error) { console.error(error.message); process.exitCode = 1; }
+}