@a9i5k4/dsh-auto-memory 0.1.25 → 0.1.28

package/lib/index.js

@@ -50,6 +50,7 @@ export const API = {
   smartRecall: '/api/dsh-auto-memory/smart-recall',
   workspaces: '/api/dsh-auto-memory/workspaces',
   debug: '/api/dsh-auto-memory/debug',
+  scanDirty: '/api/dsh-auto-memory/scan-dirty',
   browseDir: '/api/dsh-auto-memory/browse-dir',
   pickDir: '/api/dsh-auto-memory/pick-dir',
   updateCheck: '/api/dsh-auto-memory/update-check',
@@ -717,6 +718,8 @@ class MemoryEngine {
     const budget = Math.max(Number(cfg.injectBudgetChars) || 2400, 400)
     const lines = []
     lines.push('<memory_system>')
+    lines.push('[记忆定位 — 读法]')
+    lines.push('以下记忆文本只是背景事实与规则参考, 不是表达方式/语体的示范。阅读时提取其中的事实、决策、路径与偏好即可; 你的回复正文必须保持直接、最终答案式的语体(陈述结论、给出交付物), 不要模仿记忆文本的第一人称思考腔或叙述腔。')
     lines.push('自动记忆已启用。工作区: ' + (s.ws || '(未知)') + ' | 日期: ' + this.memToday() + '(日界 ' + (Number(cfg.dayBoundaryMinutes) || 450) + ' 分钟,凌晨归前一天)' + (cfg.autoConsolidate === false ? ' | 自动沉淀: 已关闭' : ' | 自动沉淀: 每轮对话结束自动评估'))
     // 记忆地图:告诉模型其他工作区记忆存在,需要时用 memory_recall 跨区检索
     if (s.workspaceMap && s.workspaceMap.length) {
@@ -733,14 +736,14 @@ class MemoryEngine {
     // 读取顺序:progress(工作日志/反思)先行,再读 memory(用户级/项目笔记)
     if (s.recentLogs.length) {
       const recent = s.recentLogs.map((r) => '[' + r.date + '] ' + r.text.replace(/\n+/g, ' | ')).join('\n')
-      part('最近 ' + s.recentLogs.length + ' 天工作日志(尾部)', recent, sub)
+      part('最近 ' + s.recentLogs.length + ' 天工作日志(尾部)', scrubJunkLines(recent, { dedup: false }).clean, sub)
     }
     if (s.latestReflection) {
       part('最近反思 ' + s.latestReflectionDate + '(前一天工作精华)', reflectionDigest(s.latestReflection), sub)
     }
-    // 敏感段落(凭据/token/密钥等)不注入 prompt,避免密钥暴露给模型
-    part('用户级记忆 ~/.dsh/memory/MEMORY.md — 跨项目,必须遵守', stripSensitiveSections(s.userText), sub)
-    part('项目长期笔记 ' + (s.notesPath || (cfg.projectMemoryDir + '/MEMORY.md')), stripSensitiveSections(s.notesText), sub)
+    // 敏感段落(凭据/token/密钥等)不注入 prompt,避免密钥暴露给模型;脏内容(乱码/重复/外部文档)清洗后再注入
+    part('用户级记忆 ~/.dsh/memory/MEMORY.md — 跨项目,必须遵守', stripSensitiveSections(sanitizeForInjection(s.userText)), sub)
+    part('项目长期笔记 ' + (s.notesPath || (cfg.projectMemoryDir + '/MEMORY.md')), stripSensitiveSections(sanitizeForInjection(s.notesText)), sub)
     // 外部记忆摘要(其他 AI 工具遗产)
     if (this.external.cache && this.external.cache.length) {
       const extBudget = Math.max(Number(cfg.externalInjectionChars) || 1400, 200)
@@ -794,6 +797,7 @@ class MemoryEngine {
     lines.push('- 自动沉淀:每轮对话结束,插件会自动评估本轮内容,把有记录价值的写进今日日志([自动沉淀] 标记),有长期价值的升格到项目笔记/用户级记忆,寒暄轮自动跳过。你仍须按上方纪律转述自己的显式记忆操作;也可调用 memory_consolidate 让 AI 读日志发散提炼长期要点。')
     lines.push('- 记忆仅作补充,不替代正常回复与交付物。')
     lines.push('- 注入上下文只含精简记忆(最近1天日志/反思精华/路径索引);**需要某天完整日志、反思全文或记忆文件全文时,调用 memory_read 按需读取(kind=log/reflection/user/notes/calendar),不要要求用户粘贴**。')
+    lines.push('- **语体纪律**:写任何记忆条目(日志/笔记/用户级/反思)都用**客观陈述**——第三人称中性句式, 只留可复用的事实/决策/规则/路径; **禁止**第一人称思维叙述("我考虑/我排查/我想"), 禁止思考腔, 禁止过程复述(过程只落结论)。')
     return lines.join('\n')
   }
 
@@ -1632,6 +1636,7 @@ class MemoryEngine {
           '- 寒暄、闲聊、单纯问候、纯测试、无实质内容 → 只输出 (无)',
           '- 有实质内容(完成工作、修复问题、做出决策、约定规则、用户偏好、讨论结论)时,提炼 1-3 条要点',
           '- 每条一句话,具体明确,不要泛泛而谈,不要复述对话过程',
+          '- 语体: 每条用第三人称客观陈述, 只写可复用的事实/决策/规则/路径; 禁止第一人称思维叙述("我考虑/我排查")与思考腔, 过程只落结论',
           '- 项目专属的进度 → [LOG];有跨会话长期价值的项目决策/架构/约定 → [NOTE];跨项目通用的用户硬性规则/偏好 → [USER]',
           '- [NOTE]/[USER] 只在真正长期有价值时用,宁缺毋滥',
           '输出格式(严格遵守):',
@@ -1751,6 +1756,7 @@ class MemoryEngine {
       '规则:',
       '- 只提炼有跨会话长期价值的:技术决策、架构约定、关键路径、用户偏好/习惯、踩过的坑及其规则',
       '- 不记临时信息(某次具体修 bug 的过程省略,但其背后的规则/约定值得记)',
+      '- 语体: 条目用第三人称客观陈述, 只落可复用结论; 禁止第一人称思维叙述与思考腔',
       '- 项目专属 → [PROJECT];跨项目通用的用户硬性规则/偏好 → [USER]',
       '- 每条一句话,简短明确;已经在下方"已有记忆"里出现的不要重复',
       '输出格式(严格遵守):',
@@ -1868,6 +1874,7 @@ class MemoryEngine {
             '- 丢弃过程流水(某次具体修 bug 的过程、临时路径、搜索结果、报错细节)',
             '- 按主题组织,可用"### 主题"小标题,每条一句话,简短明确',
             '- 不要复述日志原文,只要蒸馏后的要点',
+            '- 语体: 条目用第三人称客观陈述, 只落可复用结论; 禁止第一人称思维叙述与思考腔',
             '输出格式:markdown(### 主题 + - 要点)。若没有任何值得保留的内容,只输出一行:(无)',
             '',
             '待蒸馏日志:',
@@ -2242,24 +2249,31 @@ class ExternalMemory {
     return out
   }
 
-  /** 把某个源的内容接入本地记忆(项目笔记或用户级记忆)。 */
+  /** 把某个源"接入"本地记忆(纯链接模式 2026-08-18): 只在记忆文档里落一条指向源文件的路径指针, 不整段写入内容。
+   *  内容留在原文件, 模型需要时用 memory_read / 直接读取路径按需获取。
+   *  防止外部工具的脏内容(乱码/整篇文档/复读块)被导入进本地记忆——语义朊病毒的传播路径之一。
+   *  (本机模型为远程调用, 不需要 AI 蒸馏要点; 用户级层已有画像/偏好, 无需为导入再跑 subagent。) */
   async importInto(sourceId, target, engine, agent) {
     const srcs = await this.discover(false)
     const src = srcs.find((s) => s.id === sourceId)
     if (!src) return '外部源不存在: ' + sourceId
     if (src.kind === 'sessions') return '会话类源不支持整体接入,请用 memory_recall 按需检索(' + src.files.length + ' 个会话文件)。'
-    const stamp = '## 来自 ' + src.tool + '(' + src.name + ') — 接入于 ' + engine.memToday() // ExternalMemory 类,this 无 memToday,必须用 engine
+    const fileRefs = (src.files && src.files.length)
+      ? src.files.map((f) => '  - ' + f.path).join('\n')
+      : '  - (未知路径)'
+    const linkBlock = '## 来自 ' + src.tool + '(' + src.name + ') — 接入于 ' + engine.memToday() + ' [链接模式]\n'
+      + fileRefs + '\n- 用法: 需要时用 memory_read 或直接读取上述路径按需获取, 不整段写入。'
     if (target === 'user') {
       const p = await engine.resolvePaths(agent)
-      const body = await engine.appendText(p.userFile, '\n' + stamp + '\n' + src.content.slice(0, 120000))
+      const body = await engine.appendText(p.userFile, '\n' + linkBlock)
       engine.state.userText = body
-      return '已接入用户级记忆(' + src.name + ', ' + src.content.length + ' 字符)'
+      return '已接入用户级记忆(' + src.name + ', 链接模式 ' + src.files.length + ' 个源路径, 未写入内容)'
     }
     const p = await engine.resolvePaths(agent)
-    const body = await engine.appendText(p.notesPath, '\n' + stamp + '\n' + src.content.slice(0, 120000))
+    const body = await engine.appendText(p.notesPath, '\n' + linkBlock)
     engine.state.notesText = body
     engine.state.loadedAt = Date.now()
-    return '已接入项目笔记(' + src.name + ', ' + src.content.length + ' 字符)'
+    return '已接入项目笔记(' + src.name + ', 链接模式 ' + src.files.length + ' 个源路径, 未写入内容)'
   }
 
   /** 检查某源是否已接入用户级/项目笔记。 */
@@ -2364,6 +2378,149 @@ function stripSensitiveSections(text) {
   return out.join('\n').replace(/\n{3,}/g, '\n\n').trim()
 }
 
+
+/** 记忆卫生守卫族(0.1.27 基础加固, 2026-08-18): 在读取/写入/导入/注入四端拦截乱码、重复与外部整篇文档, 防止外部 AI 工具记忆的脏内容混入。 */
+/** 常见 GBK 残骸特征(UTF-8 被按 GBK 解码再存回)——命中即判定疑似乱码(0.1.28 补全为与 prion-scan.mjs 一致的 34 项)。 */
+var MOJIBAKE_RE = /涓婁紶|涓嬭浇|鏉ユ簮|鈥|鈶|鈮|鐨勪|鐨勫|瀹夎|鍙戦|鐢ㄦ埛|鎴戠殑|鏁版嵁|鎸佷箙|璁＄畻|婧愪簬|鏂囦欢|瀹樻柟|娴嬭瘯|鍥剧墖|杩涜涓|鎵撳紑|杈撳嚭|鏌ヨ|鑾峰彇|閰嶇疆|缂撳瓨|瀛樺偍|鍒濆|璇曟嵎|璋冭瘯|鍥剧墖|瀛︿範|鎬ц兘/
+/** 外部 AI 工具画像 raw JSON envelope 特征(整段混入的签名: memoryBlock/"uid"/updatedAt/"role")。 */
+var RAW_JSON_MARK = /memoryBlock|"uid"\s*:|updatedAt|"role"\s*:\s*"(?:user|assistant|system)"/i
+/** base64 残骸行特征(≥200 字符纯 base64 字母表)。 */
+var BASE64_LINE = /^[A-Za-z0-9+\/]{200,}={0,2}$/
+/** 检测一段文本的疑似乱码密度(命中特征字符占比)。 */
+function mojibakeDensity(text) {
+  var t = String(text || '')
+  if (!t) return 0
+  var hits = (t.match(new RegExp(MOJIBAKE_RE.source, 'g')) || []).length
+  // 按命中段长度粗算占比, 而非按字符, 避免长文本误报
+  var covered = t.length
+  var density = (hits * 8) / Math.max(1, covered)
+  return density
+}
+/** 剔除文本中的疑似乱码/外部文档行: 返回 { clean, dropped }。保守阈值 0.003 约=长文本中若干处命中。 */
+function scrubJunkLines(text, opts) {
+  var o = opts || {}
+  var lines = String(text || '').split('\n')
+  var out = []
+  var dropped = 0
+  var seen = Object.create(null)
+  var inCode = false
+  var maxLines = o.maxLines || 4000
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i]
+    if (line.length > 5000) { dropped++; continue } // 单行超长(疑似 base64/二进制)直接丢
+    if (/^```/.test(line)) { inCode = !inCode; continue } // 代码块整体不进记忆注入
+    if (inCode) { dropped++; continue }
+    // 连续重复行去重(保首次)
+    var key = line.slice(0, 60)
+    if (o.dedup && seen[key]) { dropped++; continue }
+    if (o.dedup) seen[key] = true
+    // 乱码行丢弃
+    if (mojibakeDensity(line) > 0.01) { dropped++; continue }
+    // 复读行丢弃(语义朊病毒: 念诗/单字重复)
+    if (hasStutter(line)) { dropped++; continue }
+    out.push(line)
+    if (out.length >= maxLines) break
+  }
+  return { clean: out.join('\n').replace(/\n{3,}/g, '\n\n').trim(), dropped }
+}
+/** 注入端: 清洗后再截断(头部), 供 renderMemoryDynamic 使用。 */
+function sanitizeForInjection(text, maxChars) {
+  var s = scrubJunkLines(text, { dedup: false })
+  return truncateHead(s.clean, maxChars || 2000)
+}
+/** 写入端: 单条上限 + 乱码拒写 + 连续重复拒写。返回 { ok, reason, clean }。 */
+function sanitizeForWrite(text, opts) {
+  var o = opts || {}
+  var maxEntry = o.maxEntryChars || 8000
+  var raw = String(text || '')
+  if (raw.length === 0) return { ok: false, reason: 'empty' }
+  if (mojibakeDensity(raw) > 0.001) return { ok: false, reason: 'mojibake', clean: '' }
+  if (hasStutter(raw)) return { ok: false, reason: 'stutter', clean: '' }
+  // 0.1.28: raw JSON envelope / base64 残骸拒写(防外部 AI 工具画像整段混入)
+  if (RAW_JSON_MARK.test(raw)) return { ok: false, reason: 'raw-json', clean: '' }
+  var b64line = raw.split('\n').some(function (l) { var k = l.trim(); return k.length > 100 && BASE64_LINE.test(k) })
+  if (b64line) return { ok: false, reason: 'base64', clean: '' }
+  if (raw.length > maxEntry) {
+    // 超长: 截断并标记(防止整篇文档吸入; 正常条目极少超过)
+    return { ok: true, clean: raw.slice(0, maxEntry), truncated: true }
+  }
+  // 连续行重复(同一段一模一样的行连续 ≥3 次 → 疑似退化 writer 循环; 空行打断连续, 避免把不同段落里相同的短行误判为循环)
+  var seq = 0, prev = '', repeated = false
+  for (var l of raw.split('\n')) {
+    var t = l.trim()
+    if (!t) { seq = 0; prev = ''; continue }
+    if (t === prev) { seq++; if (seq >= 3) { repeated = true; break } } else { prev = t; seq = 1 }
+  }
+  if (repeated) return { ok: false, reason: 'duplicate-lines' }
+  return { ok: true, clean: raw }
+}
+/** 写闸门拦截原因 → 中文说明(供三个写入工具返回信息)。 */
+var WRITE_GATE_REASON = { empty: '内容为空', mojibake: '疑似乱码/错误编码往返', stutter: '疑似复读退化', 'duplicate-lines': '疑似重复内容块', 'raw-json': '疑似外部画像 raw JSON envelope', base64: '疑似 base64 编码残骸行' }
+/** 追加去重复读守卫: 检查 incoming 首行是否已出现在现有内容尾部(近 60 行, 包含式匹配——日志行的 "- HH:MM " 前缀不影响判定)。 */
+function tailHas(existing, incoming) {
+  if (!existing || !incoming) return false
+  var first = String(incoming).trim().split('\n')[0].trim().slice(0, 60)
+  if (!first) return false
+  var tail = String(existing).trim().split('\n').slice(-60)
+  for (var i = 0; i < tail.length; i++) {
+    if (tail[i].indexOf(first) !== -1) return true
+  }
+  return false
+}
+/** 脏 token 检查器(prion-scan 式只读, 0.1.28 集成): 对给定文件跑四类启发式(编码异常/重复块/超长行/raw JSON), 返回 文件|行区间|类型 报告(不含正文)。 */
+async function dirtyScanForFiles(targets) {
+  var MAX_PER_FILE = 25
+  var out = []
+  for (var ti = 0; ti < (targets || []).length; ti++) {
+    var t = targets[ti]
+    var file = t && t.path
+    var label = (t && t.name) || file
+    if (!file) continue
+    var buf, sizeKB
+    try {
+      buf = await readFile(file)
+      if (buf.includes(0)) continue // 二进制跳过
+      sizeKB = Math.round((buf.length / 1024) * 10) / 10
+    } catch (e) { continue }
+    var part = buf.toString('utf8')
+    var lines = part.split('\n')
+    var findings = []
+    var addFind = function (range, type) { if (findings.length < MAX_PER_FILE) findings.push({ range: String(range), type: type }) }
+    var moji = [], jsonLines = [], longLines = [], b64 = []
+    var lineC = Object.create(null), secC = Object.create(null)
+    for (var i = 0; i < lines.length; i++) {
+      var ln = lines[i].replace(/\r$/, '')
+      var k = ln.trim()
+      if (k.length >= 8 && !/^[=\-_#*·•|\s]+$/.test(k) && !/^#{1,6}\s/.test(k)) lineC[k] = (lineC[k] || 0) + 1
+      var m = k.match(/^##\s+(.+)$/)
+      if (m) { var tt = m[1].replace(/\s+/g, ' ').slice(0, 80); secC[tt] = (secC[tt] || 0) + 1 }
+      if (mojibakeDensity(ln) > 0.001) moji.push(i + 1)
+      if (RAW_JSON_MARK.test(ln)) jsonLines.push(i + 1)
+      if (ln.length > 500) longLines.push(i + 1)
+      if (ln.length > 100 && BASE64_LINE.test(k)) b64.push(i + 1)
+    }
+    if (moji.length) addFind(moji.slice(0, 8).join(',') + (moji.length > 8 ? '…(' + moji.length + ' 行)' : ''), '编码异常 mojibake ×' + moji.length + ' 行')
+    if (jsonLines.length) addFind(jsonLines.slice(0, 8).join(',') + (jsonLines.length > 8 ? '…(' + jsonLines.length + ' 行)' : ''), '"raw JSON envelope(外部画像)" ×' + jsonLines.length + ' 行')
+    if (longLines.length) addFind(longLines.slice(0, 5).join(',') + (longLines.length > 5 ? '…' : ''), '超长行 >500 ×' + longLines.length)
+    if (b64.length) addFind(b64.slice(0, 5).join(',') + (b64.length > 5 ? '…' : ''), 'base64 残骸行 ×' + b64.length)
+    var dupKeys = Object.keys(lineC).filter(function (k2) { return lineC[k2] >= 3 }).sort(function (a, b) { return lineC[b] - lineC[a] }).slice(0, 5)
+    if (dupKeys.length) addFind('—', '重复内容行(文件内 ≥3 次) ×' + dupKeys.length + ' 组')
+    var repSec = Object.keys(secC).filter(function (t2) { return secC[t2] >= 2 }).slice(0, 5)
+    if (repSec.length) addFind('—', '重复 ## 标题 ×' + repSec.length + ' 组')
+    if (findings.length) out.push({ name: label, file: file, sizeKB: sizeKB, lines: lines.length, findings: findings })
+  }
+  return out
+}
+/** 语义朊病毒守卫: 检测词/字符级复读退化(念诗/单字重复/垃圾 token 循环)。保守、双保险。 */
+function hasStutter(text) {
+  var t = String(text || '')
+  if (!t) return false
+  // 英文/ASCII 二字符以上词连续复读 ≥4 次(空白或标点分隔都算, 覆盖 "Run. Run. Run. Run.")
+  if (/(?:^|[^\w])(\w{2,})(?:[^\w]+\1){3,}(?:[^\w]|$)/.test(t)) return true
+  // CJK/日文单字连读 ≥5 次(相邻最多隔 2 个非 CJK 字符, 覆盖念诗式 "风。风。风。风。风。")
+  if (/([\u4e00-\u9fff\u3040-\u30ff])(?:[^\u4e00-\u9fff\u3040-\u30ff]{0,2}\1){4,}/.test(t)) return true
+  return false
+}
 /** 从 session 提取消息。surface 不是完整可靠的 user 来源,因此失败时回退完整事件日志。 */
 function messageOfEvent(ev) {
   if (!ev) return null
@@ -2556,10 +2713,16 @@ export function apply(ctx, config) {
       const date = DATE_RE.test(args.date || '') ? args.date : engine.memToday()
       const p = await engine.resolvePaths(exec.agent)
       const logPath = path.join(p.projectDir, date + '.md')
-      const entry = '- ' + nowHm() + ' ' + String(args.note).trim()
+      const note = String(args.note || '').trim()
+      // 写闸门: 乱码/复读/重复行拦截 + 单条 2000 字上限(日志条目应为一句话概括)
+      const gate = sanitizeForWrite(note, { maxEntryChars: 2000 })
+      if (!gate.ok) return 'memory_log: 写入被记忆卫生闸门拦截(' + WRITE_GATE_REASON[gate.reason] + '),未写入。请改写为客观陈述后重试。'
+      const existing = engine.state.logText || (await engine.readTextSafe(logPath)) || ''
+      if (tailHas(existing, note)) return 'memory_log: 该条目与日志尾部已有内容重复,拒绝写入(复读防护)。'
+      const entry = '- ' + nowHm() + ' ' + (gate.clean || note).trim()
       const body = await engine.appendText(logPath, entry)
       if (date === engine.memToday()) { engine.state.logText = body; engine.state.logPath = logPath; engine.state.loadedAt = Date.now() }
-      return '已更新记忆文档: ' + logPath + '\n' + entry
+      return '已更新记忆文档: ' + logPath + '\n' + entry + (gate.truncated ? '\n(内容超长,已截断)' : '')
     }),
 
     defineTool('memory_note', '更新当前项目长期笔记 .dsh-memory/MEMORY.md(本项目专属的约定、决策、架构要点)。action=append 追加一段(自动带日期标题);action=replace 整体替换(需先基于注入内容或 memory_recall 结果给出完整新内容)。每日预算 3000 字/天,超限自动压缩旧内容腾空间(不拒绝写入)。**调用后必须在本轮回复正文中向用户转述:更新了项目笔记、加入什么要点**。', {
@@ -2569,17 +2732,26 @@ export function apply(ctx, config) {
       const p = await engine.resolvePaths(exec.agent)
       const content = String(args.content || '').trim()
       if (!content) return 'memory_note: content 为空,未写入。'
-      const acct = await engine.ensureBudget(exec.agent, 'note', content)
+      const replace = args.action === 'replace'
+      // 写闸门: append 单条上限 8000 字; replace(整篇重写)放行到 20 万字, 但同样经受乱码/复读/重复块质量闸门
+      const gate = sanitizeForWrite(content, { maxEntryChars: replace ? 200000 : 8000 })
+      if (!gate.ok) return 'memory_note: 写入被记忆卫生闸门拦截(' + WRITE_GATE_REASON[gate.reason] + '),未写入。请改写为客观陈述后重试。'
+      const write = gate.clean || content
+      if (!replace) {
+        const existing = engine.state.notesText || (await engine.readTextSafe(p.notesPath)) || ''
+        if (tailHas(existing, write)) return 'memory_note: 与笔记尾部已有内容重复,拒绝写入(复读防护)。'
+      }
+      const acct = await engine.ensureBudget(exec.agent, 'note', write)
       if (!acct.ok) return 'memory_note: 项目笔记今日预算已用尽(上限 ' + acct.acct.limit + ' 字/天)且自动压缩不可用(刚压缩过或 AI 不可用),本次未写入。可稍后再试或调用 memory_maintain 整理。'
       let body
-      if (args.action === 'replace') {
-        body = content
+      if (replace) {
+        body = write
         await engine.writeFull(p.notesPath, body)
       } else {
-        body = await engine.appendText(p.notesPath, '\n## ' + engine.memToday() + '\n' + content)
+        body = await engine.appendText(p.notesPath, '\n## ' + engine.memToday() + '\n' + write)
       }
       engine.state.notesText = body; engine.state.loadedAt = Date.now()
-      return '已更新项目笔记: ' + p.notesPath + '\n追加内容:\n' + content + (acct.compacted ? '\n(已自动压缩旧内容腾出空间)' : '')
+      return '已更新项目笔记: ' + p.notesPath + '\n追加内容:\n' + write + (gate.truncated ? '\n(内容超长,已截断到 ' + write.length + ' 字符)' : '') + (acct.compacted ? '\n(已自动压缩旧内容腾出空间)' : '')
     }),
 
     defineTool('memory_user', '更新用户级记忆 ~/.dsh/memory/MEMORY.md(跨所有项目的长期规则/偏好,用户明确要求记住时用)。action=append 追加;action=replace 整体替换。每日预算 4000 字/天,超限自动压缩旧内容腾空间(不拒绝写入)。**调用后必须在本轮回复正文中向用户转述:已记住该规则/偏好**。', {
@@ -2589,17 +2761,26 @@ export function apply(ctx, config) {
       const p = await engine.resolvePaths(exec.agent)
       const content = String(args.content || '').trim()
       if (!content) return 'memory_user: content 为空,未写入。'
-      const acct = await engine.ensureBudget(exec.agent, 'user', content)
+      const replace = args.action === 'replace'
+      // 写闸门: append 单条上限 8000 字; replace(整篇重写)放行到 20 万字, 但同样经受乱码/复读/重复块质量闸门
+      const gate = sanitizeForWrite(content, { maxEntryChars: replace ? 200000 : 8000 })
+      if (!gate.ok) return 'memory_user: 写入被记忆卫生闸门拦截(' + WRITE_GATE_REASON[gate.reason] + '),未写入。请改写为客观陈述后重试。'
+      const write = gate.clean || content
+      if (!replace) {
+        const existing = engine.state.userText || (await engine.readTextSafe(p.userFile)) || ''
+        if (tailHas(existing, write)) return 'memory_user: 与用户级记忆尾部已有内容重复,拒绝写入(复读防护)。'
+      }
+      const acct = await engine.ensureBudget(exec.agent, 'user', write)
       if (!acct.ok) return 'memory_user: 用户级记忆今日预算已用尽(上限 ' + acct.acct.limit + ' 字/天)且自动压缩不可用(刚压缩过或 AI 不可用),本次未写入。可稍后再试或调用 memory_maintain 整理。'
       let body
-      if (args.action === 'replace') {
-        body = content
+      if (replace) {
+        body = write
         await engine.writeFull(p.userFile, body)
       } else {
-        body = await engine.appendText(p.userFile, '\n## ' + engine.memToday() + '\n' + content)
+        body = await engine.appendText(p.userFile, '\n## ' + engine.memToday() + '\n' + write)
       }
       engine.state.userText = body; engine.state.loadedAt = Date.now()
-      return '已更新用户级记忆: ' + p.userFile + '\n追加内容:\n' + content + (acct.compacted ? '\n(已自动压缩旧内容腾出空间)' : '')
+      return '已更新用户级记忆: ' + p.userFile + '\n追加内容:\n' + write + (gate.truncated ? '\n(内容超长,已截断到 ' + write.length + ' 字符)' : '') + (acct.compacted ? '\n(已自动压缩旧内容腾出空间)' : '')
     }),
 
     defineTool('memory_read', '按需读取记忆文件完整内容(某日日志/反思全文、用户级记忆、项目笔记、日历),注入上下文只含精简摘要,需要细节时用本工具,不要要求用户粘贴。', {
@@ -2651,7 +2832,7 @@ export function apply(ctx, config) {
       text: { type: 'string', required: true, description: '完整反思内容:成果回顾 / 教训改进 / 今日可延续要点。' },
     }, async (args, exec) => engine.saveReflection(args.date, args.text, exec.agent)),
 
-    defineTool('memory_external', '查看/接入其他 AI 工具(AI 助手/CodeBuddy/Claude Code/Codex/项目约定文件)的记忆。action=list 列出全部检测到的外部记忆源(路径/大小/预览/会话数);action=import 把某源内容整体接入本地记忆(source 为源 id,target=project 接进项目笔记 / user 接进用户级记忆,自动标注来源)。首次在新工作区工作、或用户提到其他软件里做过的事时调用。', {
+    defineTool('memory_external', '查看/接入其他 AI 工具(AI 助手/CodeBuddy/Claude Code/Codex/项目约定文件)的记忆。action=list 列出全部检测到的外部记忆源(路径/大小/预览/会话数);action=import 以纯链接模式接入(source 为源 id,target=project 接进项目笔记 / user 接进用户级记忆,只记录源文件路径指针、不写入内容,需要时按需读取;防止外部脏内容混入本地记忆)。首次在新工作区工作、或用户提到其他软件里做过的事时调用。', {
       action: { type: 'string', enum: ['list', 'import'], required: true, description: 'list=列出外部记忆源; import=接入指定源。' },
       source: { type: 'string', description: '要接入的源 id(action=import 时必填,来自 list 结果)。' },
       target: { type: 'string', enum: ['project', 'user'], description: '接入目标: project=项目笔记(默认), user=用户级记忆。' },
@@ -2818,6 +2999,27 @@ export function apply(ctx, config) {
         try { writeJson(res, 200, await engine.debugInfo()) } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
+    {
+      kind: 'exact',
+      path: API.scanDirty,
+      handler: async (req, res) => {
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        if ((req.method || 'GET') !== 'GET') return writeJson(res, 405, { error: 'method not allowed' })
+        try {
+          const p = await engine.resolvePaths(undefined)
+          const targets = [
+            { name: '用户级 MEMORY.md', path: p.userFile },
+            { name: '项目笔记 MEMORY.md', path: p.notesPath },
+            { name: '今日日志 ' + engine.memToday() + '.md', path: p.logPath },
+          ]
+          const refl = await engine.listReflections(p.reflectDir, 50)
+          for (const r of refl || []) targets.push({ name: '反思 ' + (r.name || ''), path: path.join(p.reflectDir, r.name) })
+          const files = await dirtyScanForFiles(targets)
+          const totalFindings = files.reduce((n, x) => n + (x.findings ? x.findings.length : 0), 0)
+          writeJson(res, 200, { files, totalFindings, scannedAt: new Date().toISOString() })
+        } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
     {
       kind: 'exact',
       path: API.browseDir,
@@ -2937,7 +3139,12 @@ export function apply(ctx, config) {
         if (!body || typeof body.content !== 'string' || !body.content.trim()) return writeJson(res, 400, { error: 'invalid body' })
         try {
           const p = await engine.resolvePaths(undefined)
-          const text = '\n## ' + engine.memToday() + '\n' + body.content.trim()
+          // 写闸门: 概览页手动追加与三个写入工具同规则(乱码/复读/重复行拒绝, 单条 8000 字, 复读去重)
+          const gate = sanitizeForWrite(body.content.trim())
+          if (!gate.ok) return writeJson(res, 400, { error: '写入被记忆卫生闸门拦截(' + WRITE_GATE_REASON[gate.reason] + '),未写入。请改写为客观陈述后重试。' })
+          const existing = engine.state.notesText || (await engine.readTextSafe(p.notesPath)) || ''
+          if (tailHas(existing, gate.clean)) return writeJson(res, 400, { error: '与笔记尾部已有内容重复,未写入(复读防护)。' })
+          const text = '\n## ' + engine.memToday() + '\n' + gate.clean
           const updated = await engine.appendText(p.notesPath, text)
           engine.state.notesText = updated
           engine.state.loadedAt = Date.now()
@@ -3137,3 +3344,6 @@ export function apply(ctx, config) {
 
   console.log('[dsh-auto-memory] ready: engine + ' + tools.length + ' tools + injection + ' + routes.length + ' routes (external memory: ' + Object.keys(DEFAULT_CONFIG.externalSources).length + ' sources)')
 }
+
+/** 导出卫生守卫与脏 token 检查器(供 smoke-test / 回归测试直接调用)。 */
+export { sanitizeForWrite, dirtyScanForFiles, mojibakeDensity, tailHas, hasStutter, WRITE_GATE_REASON }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@a9i5k4/dsh-auto-memory",
   "description": "DSH 自动记忆插件:三层记忆(用户级/项目笔记/每日日志)自动注入与检索、每轮对话自动沉淀、每日反思、可视化面板与设置页,支持继承其他 AI 工具的记忆。",
-  "version": "0.1.25",
+  "version": "0.1.28",
   "type": "module",
   "main": "lib/index.js",
   "exports": {