@a9i5k4/dsh-auto-memory 0.1.26 → 0.1.29

package/README.md

@@ -219,6 +219,19 @@ Defaults (JSON file `~/.dsh/dsh-auto-memory.json`):
 
 Adjustable in the GUI (Settings → Auto Memory), including the UI language (zh / en), the panel font size and the day boundary.
 
+### v0.1.27 hardening (memory hygiene gate — keeps external dirt out)
+
+- **Write gate on the three write tools**: `memory_log_dev` / `memory_note_dev` / `memory_user_dev` now run content through `sanitizeForWrite` before writing — suspected mojibake (GBK round-trip artifacts), stutter degeneration (word/char loops, punctuation-separated included) and consecutive duplicate lines (≥3) are rejected with a reason; append entries cap at 8,000 chars, full rewrites (replace) at 200,000; appends are also deduped against the file's last ~60 lines (the `- HH:MM` log prefix does not affect matching).
+- **Hygiene family fixes**: removed the `进行中` false positive from the mojibake pattern (added the real artifact `杩涜涓`), switched mojibake counting to global matching (it previously counted at most 1 hit, letting dirty long texts slip past the threshold), stutter detection now works across punctuation, and the duplicate-line check is reset by blank lines (no more false positives on short lines repeated across paragraphs).
+- **External memory import is link-only**: `memory_external_dev` import now records only source file path pointers instead of copying content — keeping dirty content from other AI tools (WorkBuddy/CodeBuddy/Claude Code/Codex) out of local memory.
+- **Injection-side scrub + voice discipline**: mojibake lines, code blocks and stutter lines are scrubbed before injection; the injected block adds a "how to read memory" note and voice discipline — write all memory entries as third-person objective statements, no first-person thinking narration.
+
+### v0.1.28 dirty-token checker (prion-scan integrated — stops the "model silently degrades" class)
+
+- **Write gate now rejects raw JSON envelopes & base64 residue**: besides mojibake / stutter / duplicate lines, the write gate also rejects lines matching external-AI-profile JSON signatures (`memoryBlock` / `"uid":` / `updatedAt` / `"role":"... "`) and base64 residue lines — so an external tool profile can never be pasted into memory wholesale again.
+- **Full mojibake table (34 features, verbatim from prion-scan.mjs)**: the GBK round-trip residue list is completed, catching the exact artifacts this class of "garbage token" shows up as.
+- **New "Scan dirty tokens" in Settings → Debug Center**: one-click prion-style scan of user-level memory / project notes / today's log / reflections — returns a per-file report by line range (mojibake / raw JSON envelope / long lines >500 / base64 / duplicate lines, duplicate ## headings) with **locations only, no content**, so you can spot residual dirt without reading it.
+
 ### v0.1.9 hardening (budget / boundary / picker)
 
 - **Daily write budget with auto-compaction**: user memory ≤ 4000 chars/day, project notes ≤ 3000 chars/day (shared across sessions, reset at the day boundary). Going over the budget never rejects the write — the framework compacts the pre-today sections with an AI pass (merge duplicates, drop stale entries, keep hard facts) and then writes; if AI is unavailable, the oldest sections are archived to `archived-user.md` / `archive/notes-archived.md` (nothing is lost). Compaction is throttled to once per 10 minutes.

package/README.zh-CN.md

@@ -217,6 +217,19 @@ pnpm up @a9i5k4/dsh-auto-memory   # 或: npm install @a9i5k4/dsh-auto-memory@lat
 
 可在 GUI（设置 → 自动记忆）中调整，包括界面语言（zh / en）、界面字号与日界。
 
+### v0.1.27 基础加固（记忆卫生闸门 — 防外部脏内容污染）
+
+- **三个写入工具接入写闸门**：`memory_log_dev` / `memory_note_dev` / `memory_user_dev` 写入前先过 `sanitizeForWrite`——疑似乱码（GBK 错误编码往返产物）、复读退化（单词/单字循环，标点分隔也识别）、连续重复行（≥3）一律拒绝并回执原因；追加（append）单条上限 8000 字、整篇重写（replace）上限 20 万字；追加时与文件尾部近 60 行做复读去重（日志行的 `- HH:MM` 前缀不影响判定）。
+- **卫生函数族修复**：乱码特征表移除 `进行中` 假阳性（补真实乱码形态 `杩涜涓`）、乱码计数改为全局匹配（此前永远只计 1 处，长文本脏内容可绕过阈值）、复读检测支持标点分隔、重复行检测由空行打断（避免误伤隔段相同的短行）。
+- **外部记忆纯链接导入**：`memory_external_dev` 的 import 只落源文件路径指针，不再整段写入内容——防止其他 AI 工具（WorkBuddy/CodeBuddy/Claude Code/Codex）记忆中的脏内容经导入混入本地记忆。
+- **注入端清洗与语体纪律**：注入前自动剔除乱码行/代码块/复读行；注入块新增「记忆定位—读法」说明与语体纪律——写记忆一律第三人称客观陈述，禁止第一人称思考腔与过程复述。
+
+### v0.1.28 脏 token 检查器（prion-scan 整合 — 根治「模型无故降级」这一类问题）
+
+- **写入闸门新增 raw JSON envelope 与 base64 残骸拒写**：在乱码/复读/重复行之外，闸门还拒绝命中外部 AI 工具画像 JSON 签名（`memoryBlock` / `"uid":` / `updatedAt` / `"role":"... "`）与 base64 残骸行——外部画像再也无法整段混入本地记忆。
+- **乱码特征表补全至 34 项（与 prion-scan.mjs 逐字一致）**：覆盖 GBK 错误编码往返的全部真实残骸形态，能精确抓到这一类「垃圾 token」。
+- **新增「扫描脏 token」（设置页 → 调试中心）**：一键 prion 式扫描用户级记忆 / 项目笔记 / 今日日志 / 反思——按文件、按行区间返回 mojibake / raw JSON envelope / 超长行 >500 / base64 / 重复内容行、重复 ## 标题报告；**只给位置不含正文**，发现残骸不用读它也能定位。
+
 ### v0.1.9 加固（预算 / 日界 / 目录选择器）
 
 - **每日写入预算 + 超限自动压缩**：用户级记忆 ≤4000 字/天、项目笔记 ≤3000 字/天（所有会话共享一天额度，日界重置）。超限不拒绝写入——框架先把「今天之前」的旧内容交给 AI 压缩（合并重复、删除过期、保留硬信息）腾出空间再写；AI 不可用时把最早段落归档到 `archived-user.md` / `archive/notes-archived.md`，信息不丢。压缩 10 分钟节流。

package/lib/client.js

@@ -176,6 +176,7 @@ window.__ModuleLoader__.load({
         fExtBudget: '外部记忆注入预算(字符)', fExtBudgetHint: '外部记忆来源在上下文中的注入预算。默认 1400(路径模式下影响有限)。',
         fConsolidateMin: '自动沉淀内容门槛(字符)', fConsolidateMinHint: '本轮 user+assistant 总字符低于此值视为寒暄跳过。默认 240。',
         fAway: '暂离阈值(分钟)', fAwayHint: '距上次活动超过该值视为暂离,回归时自动弹出记忆窗口。默认 60。',
+        fAutoPopup: '自动弹出记忆窗口', fAutoPopupHint: '暂离/回归时自动弹出记忆窗口(corner)并欢迎;关闭后只能手动打开。默认开。',
         fAutoConsolidate: '自动沉淀(每轮对话结束AI评估)', fAutoConsolidateHint: '关闭后每轮对话结束不再自动调用 AI 评估与写入今日日志。',
         fConsolidate: '自动沉淀间隔(分钟)', fConsolidateHint: '两轮自动沉淀之间的最短间隔。默认 30;非工作时间(22:00-08:00)自动翻倍,避免短时间耗尽每日额度。',
         fConsolidateMax: '自动沉淀每日额度(次)', fConsolidateMaxHint: '每天最多触发自动沉淀的次数,到点后当天不再调用。默认 8。',
@@ -276,6 +277,7 @@ window.__ModuleLoader__.load({
         fExtBudget: 'External memory injection budget (chars)', fExtBudgetHint: 'Budget for external memory sources in context. Default 1400 (limited effect with path mode).',
         fConsolidateMin: 'Auto-consolidation content threshold (chars)', fConsolidateMinHint: 'Turns with fewer combined user+assistant chars are treated as chit-chat and skipped. Default 240.',
       fAway: 'Away threshold (minutes)', fAwayHint: 'Marked away when inactive longer than this; the memory panel auto-opens on return. Default 60.',
+      fAutoPopup: 'Auto-open memory panel', fAutoPopupHint: 'Auto-open the memory panel (corner) with a welcome when returning from away; disabled = open manually only. Default on.',
       fAutoConsolidate: 'Auto-consolidation (AI review each turn end)', fAutoConsolidateHint: 'When off, no automatic AI review or daily-log writes at turn end.',
       fConsolidate: 'Auto-consolidate interval (minutes)', fConsolidateHint: 'Minimum gap between auto-consolidations. Default 30; doubled automatically outside work hours (22:00-08:00).',
       fConsolidateMax: 'Daily auto-consolidate quota', fConsolidateMaxHint: 'Max auto-consolidation runs per day; no more runs after the quota is reached. Default 8.',
@@ -337,6 +339,7 @@ window.__ModuleLoader__.load({
     // 暂离检测:优先用 host 定时检测的 away 状态(阈值可配 awayMinutes),回退本地 lastActive 旧逻辑
     var hostAway = false
     var hostAwayReady = false
+    var autoPopupEnabled = true
     function isAway() {
       if (hostAwayReady) return hostAway
       var lastSeen = 0
@@ -346,6 +349,36 @@ window.__ModuleLoader__.load({
 
     // ───────────────────────── 更新弹窗 / 首次指导 ─────────────────────────
     var CHANGELOG = {
+      '0.1.29': { zh: [
+        '修复:工作区总览一直显示「未发现带记忆的工作区」——DSH 新版会话持久化改为 session.jsonl.zstd 压缩帧,旧逻辑只认 .jsonl 扫描不到任何会话;现已用 zstd 解压读取首行提取 cwd,并让空的 summary 缓存短时失效,避免空结果被永久固化。',
+        '新增:设置页「自动化」新增「自动弹出记忆窗口」开关——关闭后暂离/回归不再自动弹出 corner 问候栏,只能手动打开。',
+        '提示:这是近期稳定版(0.1.x 维护线)的发布。实验版(下一大版本)预计未来几周内发布,在此之前稳定版仅做维护性更新。',
+      ], en: [
+        'Fix: Workspace overview kept showing "No memory workspaces found" — DSH now stores sessions as session.jsonl.zstd compressed frames that were not recognized; the overview now decompresses them to read the first line and extract each workspace, and empty summary caches expire instead of being fixed forever.',
+        'New: "Auto-open memory panel" toggle in Settings → Automation - turn it off to stop auto-opening the corner greeting on away/return; the panel stays manual-only.',
+        'Note: this is a recent stable-line (0.1.x maintenance) release. The experimental next major version is expected within a few weeks; until then the stable line only receives maintenance updates.',
+      ] },
+      '0.1.28': { zh: [
+        '脏 token 检查器(prion-scan 四类启发式整合):mojibake GBK 残骸特征表补全至 34 项(与 prion-scan.mjs 逐字一致),写入闸门新增 raw JSON envelope(memoryBlock/"uid"/updatedAt/"role")与 base64 残骸行拒写——外部 AI 工具画像无法再整段混入。',
+        '新增「扫描脏 token」:设置页调试中心一键扫描用户级/项目笔记/每日日志/反思,按行区间返回 mojibake / raw JSON / 超长行 / base64 / 重复块报告(只给位置,不含正文)。',
+      ], en: [
+        'Dirty-token checker (prion-scan heuristics integrated): the GBK mojibake residue table is completed to 34 features (verbatim identical to prion-scan.mjs); the write gate now also rejects raw JSON envelopes (memoryBlock/"uid"/updatedAt/"role") and base64 residue lines — external AI tool profiles can no longer be pasted in wholesale.',
+        'New "Scan dirty tokens": one-click scan of user/notes/log/reflection files in Settings → Debug Center, reporting mojibake / raw JSON / long lines / base64 / duplicate blocks by line range (location only, no content).',
+      ] },
+      '0.1.27': { zh: [
+        '记忆卫生闸门(写端):memory_log/note/user 三个写入工具先过 sanitizeForWrite——疑似乱码(GBK 错误编码往返)/复读退化(词/字符循环,含跨标点)/连续重复行(≥3)拒绝并中文回执;append 单条上限 8000 字、replace 整篇 20 万字;追加前 tailHas 与文件尾部近 60 行做包含式复读去重。',
+        '全写入口审计:唯一漏网=API.note(概览页手动追加)已补同套闸门,回归 42 用例全过。',
+        '外部记忆接入只存路径指针,不再复制内容;注入端清洗乱码行/代码块/复读行;注入块加"记忆定位/读法"与语体纪律(条目一律第三人称客观陈述)。',
+      ], en: [
+        'Memory hygiene write gate: the three write tools (log/note/user) run through sanitizeForWrite — suspected mojibake (GBK round-trip), stutter degeneration (including punctuation-separated) and consecutive duplicate lines (≥3) are rejected with a reason; appends cap at 8,000 chars, rewrites at 200,000; appends are deduped against the last ~60 lines (tailHas).',
+        'Full write-entry audit: the only leak (API.note manual append) now goes through the same gate; 42 regression cases all pass.',
+        'External memory import records only path pointers; injection scrubs mojibake/code-block/stutter lines; the injected block adds "how to read memory" and the voice discipline (entries must be third-person objective statements).',
+      ] },
+      '0.1.20': { zh: [
+        '修复:正式发布流程 cordis.patch.yml(loader 入口 id + 包名)转换事故——发布包与开发版 identity 完全隔离,不再互相撞车。',
+      ], en: [
+        'Fix: cordis.patch.yml conversion mishap in the release pipeline (loader entry id + package name) — published package identity is now fully isolated from the dev build.',
+      ] },
       '0.1.26': { zh: [
         '文档:README 定位改为「技术先行 + 人性化」——intro 强调缓存友好三层记忆引擎,新增「底层工程」章节(前缀缓存友好/注入精简/AI限频/凭据过滤/跨工具),与「主动懂你的伙伴」章节互补。',
       ], en: [
@@ -504,6 +537,7 @@ window.__ModuleLoader__.load({
       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',
@@ -1692,6 +1726,25 @@ window.__ModuleLoader__.load({
       var busyPair = useState(false)
       var busy = busyPair[0]
       var setBusy = busyPair[1]
+      var scanPair = useState(null)
+      var scan = scanPair[0]
+      var setScan = scanPair[1]
+      var scanBusyPair = useState(false)
+      var scanBusy = scanBusyPair[0]
+      var setScanBusy = scanBusyPair[1]
+      var scanFiles = scan && scan.files ? scan.files : null
+      var filesTotal = scan && scan.files ? scan.files.length : 0
+      var totalFindings = scan ? (scan.totalFindings || 0) : 0
+      var scanError = scan && scan.error ? scan.error : ''
+      function runScan() {
+        if (scanBusy) return
+        setScanBusy(true)
+        setScan(null)
+        fetch(API.scanDirty).then(function (r) { return r.json() }).then(function (d) {
+          setScan(d || {})
+          setScanBusy(false)
+        }).catch(function (e) { setScan({ error: String(e && e.message || e) }); setScanBusy(false) })
+      }
       function refresh() {
         if (busy) return
         setBusy(true)
@@ -1737,7 +1790,16 @@ window.__ModuleLoader__.load({
         kv(t('kvDup'), data.duplicateHeadings + t('kvDupCount'), data.duplicateHeadings > 0),
         kv(t('kvMem'), t('kvMemUser') + ' ' + (data.memoryFiles.user.exists ? fmtSize(data.memoryFiles.user.size) : t('kvMemMissing')) + ' · ' + t('kvMemNotes') + ' ' + (data.memoryFiles.notes.exists ? fmtSize(data.memoryFiles.notes.size) : t('kvMemMissing')) + ' · ' + t('kvMemLog') + ' ' + (data.memoryFiles.log.exists ? fmtSize(data.memoryFiles.log.size) : t('kvMemMissing')), !data.memoryFiles.log.exists),
         kv(t('kvWs'), currentWs() || t('kvWsUnknown'), false),
-        kv(t('kvApi'), probes ? Object.keys(probes).map(function (k) { return k + '=' + (probes[k].status !== undefined ? probes[k].status : probes[k].error) }).join('  ') : '…', apiBad))
+        kv(t('kvApi'), probes ? Object.keys(probes).map(function (k) { return k + '=' + (probes[k].status !== undefined ? probes[k].status : probes[k].error) }).join('  ') : '…', apiBad),
+        h('div', { 'data-dam-row': '', style: { marginTop: '6px', alignItems: 'flex-start', flexDirection: 'column' } },
+          h('div', { 'data-dam-row': '' },
+            h('button', { 'data-dam-btn': '', title: 'prion-scan 式四类启发式,只报位置不含正文', onClick: runScan, disabled: scanBusy }, scanBusy ? (locale === 'zh' ? '扫描中…' : 'Scanning…') : (locale === 'zh' ? '扫描脏 token' : 'Scan dirty tokens')),
+            h('span', { 'data-dam-hint': '', style: { marginLeft: '8px' } }, scanError ? scanError : (scan === null ? (locale === 'zh' ? '检查用户级/笔记/日志/反思的 mojibake / raw JSON / 超长行 / base64 / 重复块' : 'Check user/notes/log/reflections: mojibake, raw JSON, long lines, base64, duplicates') : (scanFiles && scanFiles.length ? (locale === 'zh' ? '共 ' + filesTotal + ' 个文件,命中 ' + totalFindings + ' 处' : filesTotal + ' files, ' + totalFindings + ' findings') : (locale === 'zh' ? '✓ 未发现脏 token' : '✓ no dirty tokens'))))),
+          scanFiles && scanFiles.length ? scanFiles.map(function (sf) {
+            return h('div', { 'data-dam-row': '', style: { alignItems: 'flex-start', flexDirection: 'column', gap: '2px', marginTop: '4px' } },
+              h('span', { style: { fontWeight: 600, fontSize: 'calc(11px * var(--dam-scale))' } }, sf.name + ' [' + sf.sizeKB + 'KB, ' + sf.lines + ' 行]'),
+              sf.findings.map(function (fd) { return h('div', { 'data-dam-hint': '', style: { whiteSpace: 'pre-wrap' } }, '行 ' + fd.range + ' ｜ ' + fd.type) }))
+          }) : null))
     }
 
     // ───────────────────────── 更新弹窗 / 首次指导(毛玻璃) ─────────────────────────
@@ -2008,6 +2070,7 @@ window.__ModuleLoader__.load({
         field(t('fAutoConsolidate'), h('input', { type: 'checkbox', checked: cfg.autoConsolidate !== false, onChange: function (e) { set('autoConsolidate', e.target.checked) } }), t('fAutoConsolidateHint')),
         field(t('fConsolidate'), h('input', { 'data-dam-input': '', type: 'number', min: 5, value: cfg.autoConsolidateCooldownMinutes === undefined ? 30 : cfg.autoConsolidateCooldownMinutes, onChange: function (e) { set('autoConsolidateCooldownMinutes', Number(e.target.value) || 30) } }), t('fConsolidateHint')),
         field(t('fConsolidateMax'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 50, value: cfg.autoConsolidateDailyMax === undefined ? 8 : cfg.autoConsolidateDailyMax, onChange: function (e) { set('autoConsolidateDailyMax', Number(e.target.value) || 8) } }), t('fConsolidateMaxHint')),
+        field(t('fAutoPopup'), h('input', { type: 'checkbox', checked: cfg.autoPopupEnabled !== false, onChange: function (e) { set('autoPopupEnabled', e.target.checked) } }), t('fAutoPopupHint')),
         field(t('fAway'), h('input', { 'data-dam-input': '', type: 'number', min: 1, value: cfg.awayMinutes || 60, onChange: function (e) { set('awayMinutes', Number(e.target.value) || 60) } }), t('fAwayHint')),
         field(t('fAutoSum'), h('input', { 'data-dam-input': '', value: (cfg.autoSummaryTimes || []).join(','), onChange: function (e) { set('autoSummaryTimes', String(e.target.value || '').split(',').map(function (s) { return s.trim() }).filter(Boolean)) } }), t('fAutoSumHint')),
         field(t('fDayBoundary'), h('input', { 'data-dam-input': '', type: 'number', min: 0, max: 1439, value: (cfg.dayBoundaryMinutes === undefined ? 450 : cfg.dayBoundaryMinutes), onChange: function (e) { set('dayBoundaryMinutes', parseInt(e.target.value || '0', 10)) } }), t('fDayBoundaryHint')),
@@ -2059,6 +2122,7 @@ window.__ModuleLoader__.load({
       applyLocalePref('system')
       apiGet(API.config).then(function (d) {
         if (d && d.config && d.config.locale) applyLocalePref(d.config.locale)
+        if (d && d.config && typeof d.config.autoPopupEnabled === 'boolean') autoPopupEnabled = d.config.autoPopupEnabled
       }).catch(function () {})
       // DSH 系统语言变化:跟随更新 + 重渲染 + 重注册入口 label
       ctx.on('locale/change', function (snap) {
@@ -2077,6 +2141,7 @@ window.__ModuleLoader__.load({
       var prevAwayState = null
       function autoOpenOnReturn() {
         try {
+          if (autoPopupEnabled === false) { prevAwayState = hostAwayReady ? hostAway : prevAwayState; return }
           if (hostAwayReady && prevAwayState === true && hostAway === false) {
             // 暂离回归:打开窗口 + 欢迎弹窗(若有待展示总结一并显示)
             if (!controller.isOpen()) controller.open()
@@ -2143,6 +2208,7 @@ window.__ModuleLoader__.load({
               hostAway = d.away
               hostAwayReady = true
             }
+            if (d && typeof d.autoPopupEnabled === 'boolean') autoPopupEnabled = d.autoPopupEnabled
             if (d && d.pendingSummary && d.pendingSummary.summary) {
               var seenKey = 'dsh-auto-memory.seenSummary.' + (d.pendingSummary.date || '') + '.' + (d.pendingSummary.time || '')
               try {

package/lib/index.js

@@ -25,6 +25,10 @@ const execP = promisify(cpExec)
 import { homedir } from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import * as nodeZlib from 'node:zlib'
+
+/** zstd 解压(DSH 新版会话持久化 session.jsonl.zstd);Node <22 无此能力时为空,自动回退明文读。 */
+const zstdDec = typeof nodeZlib.zstdDecompressSync === 'function' ? nodeZlib.zstdDecompressSync : null
 
 /** Stable cordis plugin name. */
 export const name = 'auto-memory'
@@ -50,6 +54,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',
@@ -91,6 +96,8 @@ const DEFAULT_CONFIG = {
   autoConsolidateDailyMax: 8,
   /** 暂离阈值(分钟):距上次活动超过该值视为暂离,回归时自动弹出记忆窗口并欢迎。默认 60。 */
   awayMinutes: 60,
+  /** 暂离回来自动弹出记忆窗口(corner/问候栏)开关:false=关闭,只能手动打开。默认 true。 */
+  autoPopupEnabled: true,
   /** 自动总结时间点(24h "HH:MM" 数组,如 ["12:00","18:00","22:00"]):到点自动生成本时段总结并弹窗展示。空数组=关闭。 */
   autoSummaryTimes: [],
   /** 日界(分钟,从 0 点起算):凌晨在此之前的活儿归前一天日志;默认 450=早上 7:30 后才进入新一天。 */
@@ -717,6 +724,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 +742,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 +803,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')
   }
 
@@ -1042,8 +1052,18 @@ class MemoryEngine {
   }
 
   // ---------- 工作区总览(跨工作区全局总结) ----------
-  /** 读 jsonl 首行(session header)。 */
+  /** 读 jsonl 首行(session header);.jsonl 明文流式读首行,.jsonl.zstd 为 zstd 压缩帧(整块解压后取首行,与 dsh 核心 dsh-session-persistence-jsonl 一致)。 */
   readFirstLine(p) {
+    if (p.endsWith('.zstd')) {
+      return readFile(p).then((buf) => {
+        try {
+          const dec = zstdDec ? zstdDec(buf) : null
+          const text = (dec || buf).toString('utf8')
+          const i = text.indexOf('\n')
+          return i >= 0 ? text.slice(0, i) : text
+        } catch (e) { return '' }
+      }).catch(() => '')
+    }
     return new Promise((resolve) => {
       const rs = createReadStream(p, { encoding: 'utf8' })
       let buf = ''
@@ -1068,7 +1088,7 @@ class MemoryEngine {
       for (const en of entries) {
         if (out.size >= 30) return
         if (en.isDirectory()) await walk(path.join(dir, en.name), depth + 1)
-        else if (en.isFile() && en.name.endsWith('.jsonl')) {
+        else if (en.isFile() && (en.name.endsWith('.jsonl.zstd') || en.name.endsWith('.jsonl'))) {
           try {
             const first = await this.readFirstLine(path.join(dir, en.name))
             if (first) {
@@ -1108,7 +1128,11 @@ class MemoryEngine {
         const raw = await this.readTextSafe(cacheFile)
         if (raw) {
           const j = JSON.parse(raw)
-          if (j && Array.isArray(j.workspaces) && j.graph && Array.isArray(j.graph.topics) && Array.isArray(j.graph.links)) return { workspaces: j.workspaces, graph: j.graph, cached: true, generatedAt: j.generatedAt }
+          // 空结果只短时信任(≤30 分钟),防止旧版 bug 产出的"空缓存"被永久复用导致永远显示"未发现带记忆的工作区"
+          const ageMs = Date.now() - (Number(j && j.generatedAt) || 0)
+          const list = j && Array.isArray(j.workspaces) ? j.workspaces : null
+          const valid = !!list && (list.length > 0 || (ageMs >= 0 && ageMs <= 30 * 60 * 1000))
+          if (valid && j.graph && Array.isArray(j.graph.topics) && Array.isArray(j.graph.links)) return { workspaces: list, graph: j.graph, cached: true, generatedAt: j.generatedAt }
         }
       } catch (e) {}
     }
@@ -1121,6 +1145,11 @@ class MemoryEngine {
       const fallbackItems = mem.logs.flatMap((l) => l.text.split('\n').filter((x) => x.trim().startsWith('- ')).map((x) => x.trim().replace(/^- /, '').slice(0, 120))).slice(-5)
       return { path: cwd, name, input: { name, logs: logText.slice(0, 5200) || '(无)', notes: mem.notes || '(无)' }, fallbackItems, logCount: fallbackItems.length, dateRange: mem.logs.length ? (mem.logs[mem.logs.length - 1].date + ' ~ ' + mem.logs[0].date) : '' }
     }))).filter(Boolean)
+    if (!records.length) {
+      const empty = { workspaces: [], graph: { topics: [], links: [] }, generatedAt: Date.now() }
+      try { await mkdir(path.dirname(cacheFile), { recursive: true }); await writeFile(cacheFile, JSON.stringify(empty, null, 2), 'utf8') } catch (e) {}
+      return { workspaces: [], graph: empty.graph, cached: false, generatedAt: empty.generatedAt }
+    }
     const fallback = records.map((r) => ({ path: r.path, name: r.name, summary: '', items: r.fallbackItems, graphTopics: r.fallbackItems.slice(0, 4).map((label) => ({ label, detail: '' })), logCount: r.logCount, dateRange: r.dateRange }))
     let workspaces = fallback
     let graph = { topics: [], links: [] }
@@ -1632,6 +1661,7 @@ class MemoryEngine {
           '- 寒暄、闲聊、单纯问候、纯测试、无实质内容 → 只输出 (无)',
           '- 有实质内容(完成工作、修复问题、做出决策、约定规则、用户偏好、讨论结论)时,提炼 1-3 条要点',
           '- 每条一句话,具体明确,不要泛泛而谈,不要复述对话过程',
+          '- 语体: 每条用第三人称客观陈述, 只写可复用的事实/决策/规则/路径; 禁止第一人称思维叙述("我考虑/我排查")与思考腔, 过程只落结论',
           '- 项目专属的进度 → [LOG];有跨会话长期价值的项目决策/架构/约定 → [NOTE];跨项目通用的用户硬性规则/偏好 → [USER]',
           '- [NOTE]/[USER] 只在真正长期有价值时用,宁缺毋滥',
           '输出格式(严格遵守):',
@@ -1751,6 +1781,7 @@ class MemoryEngine {
       '规则:',
       '- 只提炼有跨会话长期价值的:技术决策、架构约定、关键路径、用户偏好/习惯、踩过的坑及其规则',
       '- 不记临时信息(某次具体修 bug 的过程省略,但其背后的规则/约定值得记)',
+      '- 语体: 条目用第三人称客观陈述, 只落可复用结论; 禁止第一人称思维叙述与思考腔',
       '- 项目专属 → [PROJECT];跨项目通用的用户硬性规则/偏好 → [USER]',
       '- 每条一句话,简短明确;已经在下方"已有记忆"里出现的不要重复',
       '输出格式(严格遵守):',
@@ -1868,6 +1899,7 @@ class MemoryEngine {
             '- 丢弃过程流水(某次具体修 bug 的过程、临时路径、搜索结果、报错细节)',
             '- 按主题组织,可用"### 主题"小标题,每条一句话,简短明确',
             '- 不要复述日志原文,只要蒸馏后的要点',
+            '- 语体: 条目用第三人称客观陈述, 只落可复用结论; 禁止第一人称思维叙述与思考腔',
             '输出格式:markdown(### 主题 + - 要点)。若没有任何值得保留的内容,只输出一行:(无)',
             '',
             '待蒸馏日志:',
@@ -1949,6 +1981,7 @@ class MemoryEngine {
       // 时间检测:暂离状态 / 待展示的自动总结 / 相关配置
       away: !!this.state.away,
       awayMinutes: Math.max(Number(this.config.awayMinutes) || 60, 1),
+      autoPopupEnabled: this.config.autoPopupEnabled !== false,
       autoSummaryTimes: Array.isArray(this.config.autoSummaryTimes) ? this.config.autoSummaryTimes : [],
       pendingSummary: this.state.pendingSummary || null,
       autoStats: this.autoStats,
@@ -2242,24 +2275,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 +2404,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 +2739,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 +2758,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 +2787,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 +2858,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 +3025,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 +3165,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 +3370,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.26",
+  "version": "0.1.29",
   "type": "module",
   "main": "lib/index.js",
   "exports": {