@max-null/dsh-memory 0.6.1 → 0.7.1

package/dist/engine.js

@@ -5,7 +5,7 @@
  * is always created `suggested` and becomes effective only through `setStatus`.
  */
 import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { Service } from '@deepseek-ai/cordis';
@@ -14,14 +14,45 @@ import { defineDomain, domainTable, DomainFacility } from '@deepseek-ai/dsh-stor
 import { JsonStorageBackend } from '@deepseek-ai/dsh-storage-json';
 import { bm25FieldScores, cosineSimilarity, rrfFuse } from "./bm25.js";
 import { parsePromptFile, scanPromptDir, writePromptFile } from "./prompt-files.js";
+import { detectSensitive } from "./quarantine.js";
+import { SELF_VERSION } from "./self.js";
+import { anchorHolds } from "./anchors.js";
+import { QueryLog, rankGapCandidates, summarizeQueryLog, summarizeSources } from "./query-log.js";
 /** Brand a string as a {@link MemoryId} (compile-time only). */
 export function MemoryId(id) {
     return id;
 }
+/** 自动升常驻所需的命中次数（2026-09-15）：一次偶然命中不足以证明「每轮都值得付费」。 */
+const AUTO_INJECT_HITS = 2;
+/**
+ * 一次检索里最多把前多少条记为「被使用」（2026-09-15）。
+ *
+ * 不设上限时，命中计数退化成「和查询有任意字符重叠」：BM25 对常见 2-gram 会给全库打分，
+ * 一句「实机验证标记」在本机就能命中 81 条，于是**两次检索把所有 approved 记忆都升成常驻**，
+ * 注入预算当场被历史条目占满——「反复被命中才值得每轮付费」这个判据也就失效了。
+ * 取前 K 名接近「模型真的会看的那几条」，且与检索返回值解耦（返回值不动）。
+ */
+const HIT_MARK_LIMIT = 5;
+/** 反查候选的正文摘要长度（字符）。 */
+const GAP_EXCERPT_CHARS = 160;
+/** 自动降级的天数阈值（2026-09-15）：与面板的冷数据判定（COLD_DAYS=30）对齐。 */
+const AUTO_DEMOTE_DAYS = 30;
 const blockSchema = z.object({
     namespace: z.enum(['global', 'project']),
     status: z.enum(['suggested', 'approved', 'auto', 'suggest']),
     injected: z.boolean().optional(),
+    quarantined: z.boolean().optional(),
+    quarantineReason: z.string().optional(),
+    hitCount: z.number().optional(),
+    source: z.enum(['agent', 'human']).optional(),
+    injectedAuto: z.boolean().optional(),
+    anchor: z.object({
+        kind: z.enum(['env', 'tool-list', 'self-version']),
+        name: z.string().optional(),
+        value: z.string(),
+    }).optional(),
+    stale: z.boolean().optional(),
+    staleReason: z.string().optional(),
     content: z.string(),
     keywords: z.array(z.string()),
     createdAt: z.number(),
@@ -97,6 +128,15 @@ function toRecord(id, block) {
         createdAt: block.createdAt,
         updatedAt: block.updatedAt,
         ...block.lastUsedAt === undefined ? {} : { lastUsedAt: block.lastUsedAt },
+        quarantined: block.quarantined === true,
+        ...block.quarantineReason === undefined ? {} : { quarantineReason: block.quarantineReason },
+        hitCount: block.hitCount ?? 0,
+        // ⑧ 来源（2026-09-15）：旧记录无此字段 → 不透传（= 来源未知），不猜
+        ...block.source === undefined ? {} : { source: block.source },
+        ...block.injectedAuto === undefined ? {} : { injectedAuto: block.injectedAuto },
+        ...block.anchor === undefined ? {} : { anchor: block.anchor },
+        ...block.stale === undefined ? {} : { stale: block.stale },
+        ...block.staleReason === undefined ? {} : { staleReason: block.staleReason },
     };
     // 0.6.0 模板库字段（缺省 fact；prompt 元数据透传）
     return {
@@ -130,6 +170,12 @@ export class MemoryEngine extends Service {
     /** backend 只注册一次（registry 重名抛 duplicate；reload 清缓存后不得重复注册）。 */
     registeredProjectBackends = new Set();
     facility;
+    /** 各存储文件上次被我们确认过的指纹；用于识别「另一个实例写过」。 */
+    storeStamps = new Map();
+    /** 写入串行链：「刷新—读—改—写」必须整体互斥，否则并发写会在其间穿插。 */
+    writeChain = Promise.resolve();
+    /** 会话启动维护只跑一次的标记（2026-09-15）。 */
+    maintenanceDone = false;
     constructor(ctx, config = {}) {
         super(ctx, 'memory');
         this.config = config;
@@ -226,8 +272,92 @@ export class MemoryEngine extends Service {
         this.projectFacilities.clear();
         await this.openGlobalFacility();
     }
-    /** Create one record in `suggested` status — never self-promoting. */
+    /**
+     * Create one record. 低危内容直接 `approved`（静默生效，2026-09-15 静默记忆机制）；
+     * 命中危险内容规则则隔离：`status` 留 `suggested`（天然不注入）**并且**置
+     * `quarantined`（不进检索），双保险，等待人工放行或删除。
+     */
+    // ── 多实例写入协调（2026-09-17）────────────────────────────────────────
+    //
+    // 另一个 DSH 实例（web 与 SSiD 同时运行）共用同一个 DSH_HOME 时，它写的记忆只落在
+    // 磁盘上；我们的内存态若比磁盘旧，下一次整份覆盖就会把对方的新记忆抹掉。DSH 的
+    // 存储层明确不做跨进程协调（storage-json「writer per process and last-write-wins
+    // is correct」、storage-sqlite「cross-process coordination is out of scope」），
+    // 所以协调放在这里：开写前比对存储文件指纹，变过就重载——等价于「update 前先
+    // select」。残余窗口只剩两个实例真正同时写，而记忆写入是低频操作。
+    /** 文件指纹：mtime + size（size 兜住同一毫秒内的两次写）。 */
+    static fileStamp(file) {
+        try {
+            const stat = statSync(file);
+            return `${stat.mtimeMs}:${stat.size}`;
+        }
+        catch {
+            return 'missing';
+        }
+    }
+    /** 全局记忆的存储文件（JsonStorageBackend 的 unit 文件名 = domain 名）。 */
+    globalStoreFile() {
+        return join(this.config.globalRoot ?? globalRoot(), 'memory.json');
+    }
+    /** 某工作区记忆的存储文件。 */
+    projectStoreFile(projectCwd) {
+        const key = join(projectCwd);
+        return join(this.projectRootFor(key), `${this.projectBackendName(key)}.json`);
+    }
+    /** 记录当前指纹，作为「这就是我们造成的状态」的基准（写入完成后调用）。 */
+    noteStoreStamps(projectCwd) {
+        const global = this.globalStoreFile();
+        this.storeStamps.set(global, MemoryEngine.fileStamp(global));
+        const scopes = new Set(this.projectTables.keys());
+        if (projectCwd !== undefined && projectCwd !== '')
+            scopes.add(join(projectCwd));
+        for (const key of scopes) {
+            const file = this.projectStoreFile(key);
+            this.storeStamps.set(file, MemoryEngine.fileStamp(file));
+        }
+    }
+    /**
+     * 写前新鲜度门：存储文件被外部改过就重载，避免整份覆盖吃掉对方的写入。
+     * 必须在取表**之前**调用——{@link reload} 重开 facility，此前取到的 table 引用会失效。
+     */
+    async refreshForWrite(projectCwd) {
+        if (this.storeStamps.size === 0) {
+            this.noteStoreStamps(projectCwd);
+            return;
+        }
+        const files = [this.globalStoreFile()];
+        if (projectCwd !== undefined && projectCwd !== '')
+            files.push(this.projectStoreFile(projectCwd));
+        for (const file of files) {
+            if (MemoryEngine.fileStamp(file) === this.storeStamps.get(file))
+                continue;
+            await this.reload();
+            this.noteStoreStamps(projectCwd);
+            return;
+        }
+    }
+    /**
+     * 一次写入的完整作用域：串行化 → 新鲜度门 → 执行 → 记指纹。
+     * 刷新与「读—改—写」必须同处一个互斥区，否则并发写会在两者之间穿插。
+     * @param projectCwd - 本次写入涉及的工作区；无则只覆盖全局存储。
+     * @param run - 实际的读改写；必须在内部重新取表（刷新后旧引用失效）。
+     * @returns `run` 的返回值。
+     */
+    writeScope(projectCwd, run) {
+        const task = this.writeChain.then(async () => {
+            await this.refreshForWrite(projectCwd);
+            const result = await run();
+            this.noteStoreStamps(projectCwd);
+            return result;
+        });
+        this.writeChain = task.then(() => undefined, () => undefined);
+        return task;
+    }
     async remember(input, projectCwd) {
+        return this.writeScope(projectCwd, () => this.rememberInner(input, projectCwd));
+    }
+    /** {@link remember} 的实现体；必须经 `writeScope` 进入（多实例写入协调）。 */
+    async rememberInner(input, projectCwd) {
         const namespace = input.namespace ?? 'global';
         const table = namespace === 'project'
             ? await this.projectTableFor(projectCwd)
@@ -236,14 +366,23 @@ export class MemoryEngine extends Service {
             throw new Error('cannot write project memory without a workspace cwd');
         const id = randomUUID();
         const now = Date.now();
+        // 关键词一并参与判定：密钥塞进 keywords 同样会在检索结果里外泄
+        const verdict = detectSensitive(input.content, ...(input.keywords ?? []));
         const block = {
             namespace,
-            status: 'suggested',
+            status: verdict.quarantined ? 'suggested' : 'approved',
             injected: false,
             content: input.content,
             keywords: (input.keywords ?? []).map(keyword => keyword.toLowerCase()),
             createdAt: now,
             updatedAt: now,
+            // ⑧ 来源（2026-09-15）：缺省 'agent'——写入这条记忆的就是主模型
+            source: input.source ?? 'agent',
+            // 有效性锚点（可选）：值变了这条记忆会被标 stale，不再被当成仍然正确
+            ...input.anchor === undefined ? {} : { anchor: input.anchor },
+            ...verdict.quarantined
+                ? { quarantined: true, ...verdict.reason === undefined ? {} : { quarantineReason: verdict.reason } }
+                : {},
         };
         await table.put(id, block);
         const record = toRecord(id, block);
@@ -252,12 +391,30 @@ export class MemoryEngine extends Service {
     }
     async list(filter, projectCwd) {
         const records = await this.allRecords(filter?.namespace, projectCwd);
-        return records.filter(record => (filter?.status === undefined || record.status === filter.status)
+        return records.filter(record => 
+        // 隔离记录默认整体排除（不进列表、不进检索，因而也不进注入预览）；
+        // 面板要用 filter.quarantined === true 显式取出来审（2026-09-15）。
+        (filter?.quarantined === undefined ? record.quarantined !== true : record.quarantined === filter.quarantined)
+            && (filter?.status === undefined || record.status === filter.status)
             && (filter?.injected === undefined || record.injected === filter.injected)
             && (filter?.kind === undefined || (record.kind ?? 'fact') === filter.kind));
     }
+    /**
+     * 关键词检索。每次成功返回的检索都记一条查询日志（⑥ 2026-09-15）——命中与否都记：
+     * 漏检不产生任何事件，只有日志能事后回答「哪些查询本该命中谁」（反例 4）。日志是旁路：
+     * 写失败只记 warn，绝不改变本次检索结果。
+     */
     async search(query, filter, projectCwd) {
-        const records = await this.list(filter, projectCwd);
+        const hits = await this.rank(query, filter, projectCwd);
+        this.recordQuery(query, hits.length, filter);
+        return hits;
+    }
+    /** 检索打分本体（BM25 + 可选语义融合）；查询日志由 {@link search} 记录。 */
+    async rank(query, filter, projectCwd) {
+        // 记忆检索默认只看 fact（2026-09-15）：模板是文件库、有独立的 prompt_search 通道，
+        // 混进来的代价不只是占返回条数——模板也会被记命中，然后「因为经常被搜到」升成常驻。
+        // 显式传 kind 的调用方（prompt_search）照旧生效。
+        const records = await this.list({ kind: 'fact', ...filter }, projectCwd);
         // 0.5.2：content 与 keywords 分离打加权 BM25（人工关键词命中权重更高）
         const scores = bm25FieldScores(query, records.map(record => ({
             body: record.content,
@@ -267,8 +424,10 @@ export class MemoryEngine extends Service {
             .map((record, index) => ({ record, score: scores[index] ?? 0 }))
             .filter(hit => hit.score > 0)
             .sort((left, right) => right.score - left.score);
-        // 0.5.3：命中即标记使用（冷热追踪）——写回按命中快照之后执行，不影响本次结果
-        await this.markUsed(bm25Ranked.map(hit => hit.record.id), projectCwd);
+        // 0.5.3：命中即标记使用（冷热追踪）——写回按命中快照之后执行，不影响本次结果。
+        // 2026-09-15：只记前 `HIT_MARK_LIMIT` 名（BM25 命中面极宽，全记等于给全库计数）；
+        // 记账在语义融合之前，按 BM25 名次取，融合结果只影响返回顺序、不影响计数。
+        await this.markUsed(bm25Ranked.slice(0, HIT_MARK_LIMIT).map(hit => hit.record.id), projectCwd);
         // 0.5.2：配置 embeddings 时与语义结果 RRF 融合；缺省/失败降级回纯 BM25
         if (this.config.embeddings === undefined)
             return bm25Ranked;
@@ -343,6 +502,56 @@ export class MemoryEngine extends Service {
             .slice(0, topK);
     }
     /** 按已知 id 定位记录所在表（global 优先，其次当前工作区表）。 */
+    /**
+     * 会话启动维护（2026-09-15）：一次扫描做完三件事——旧数据迁移、长期未命中的自动降级、
+     * 锚点批量校验。只跑一次、幂等、**失败不阻断**（记忆可用性优先于维护完成度）。
+     *
+     * 调用点在 `ensureProjectOpen`：它是 async，且每会话首次打开工作区表时必经。
+     * `memory:recall` 的 provider 是**同步**回调，不能在那里 await。
+     *
+     * @param projectCwd - 会话工作区：迁移/降级/校验都连它一起处理。
+     */
+    async runMaintenanceOnce(projectCwd) {
+        if (this.maintenanceDone)
+            return;
+        this.maintenanceDone = true;
+        try {
+            const migration = await this.migrateLegacy(projectCwd);
+            if (migration.approved > 0 || migration.quarantined > 0 || migration.counted > 0) {
+                this.ctx.logger?.info?.(`dsh-memory: 旧数据迁移 放行 ${migration.approved} / 隔离 ${migration.quarantined}`
+                    + ` / 回填计数 ${migration.counted}`);
+            }
+            const demoted = await this.demoteStale(projectCwd);
+            if (demoted > 0)
+                this.ctx.logger?.info?.(`dsh-memory: 长期未命中，撤下常驻 ${demoted} 条`);
+            const staled = await this.verifyAnchors(this.anchorProbes(), projectCwd);
+            if (staled > 0)
+                this.ctx.logger?.info?.(`dsh-memory: 锚点校验更新 ${staled} 条`);
+        }
+        catch (error) {
+            this.ctx.logger?.warn?.(`dsh-memory: 启动维护失败（不影响使用）：${String(error)}`);
+        }
+    }
+    /**
+     * 锚点探测上下文。`toolNames` 拿不到时返回 `undefined`——**不能给空数组**：那会被判成
+     * 「工具全没了」，让所有 `tool-list` 锚点误失效。
+     */
+    anchorProbes() {
+        let toolNames;
+        try {
+            const tools = this.ctx.get('tools');
+            const listed = tools?.list?.();
+            if (Array.isArray(listed)) {
+                toolNames = listed
+                    .map(tool => tool.name)
+                    .filter((name) => typeof name === 'string');
+            }
+        }
+        catch {
+            toolNames = undefined;
+        }
+        return { ...(toolNames === undefined ? {} : { toolNames }), selfVersion: SELF_VERSION };
+    }
     tableOf(id, projectCwd) {
         const global = this.requireTable('global');
         if (global.get(id) !== undefined)
@@ -352,29 +561,327 @@ export class MemoryEngine extends Service {
         const project = this.projectTables.get(join(projectCwd));
         return project !== undefined && project.get(id) !== undefined ? project : undefined;
     }
-    /** 命中标记：把 lastUsedAt 写回（命中记录不存在时跳过；不 emit 事件——统计性字段）。 */
+    /** 命中标记：写回 lastUsedAt 与命中次数，达标即自动升常驻（2026-09-15）。 */
     async markUsed(ids, projectCwd) {
+        return this.writeScope(projectCwd, () => this.markUsedInner(ids, projectCwd));
+    }
+    /** {@link markUsed} 的实现体；必须经 `writeScope` 进入（`recordUse` 在此之内）。 */
+    async markUsedInner(ids, projectCwd) {
         if (ids.length === 0)
             return;
         const now = Date.now();
         const global = this.requireTable('global');
-        const project = projectCwd === undefined || projectCwd === ''
-            ? undefined
-            : this.projectTables.get(join(projectCwd));
+        // 取表走异步版：`writeScope` 可能在本次进入前刚 `reload()`（外部实例改过存储），
+        // 那时同步缓存已被清空——继续读缓存会把 project 侧的命中静默漏记。
+        const project = await this.projectTableFor(projectCwd);
         for (const id of ids) {
             const globalBlock = global.get(id);
             if (globalBlock !== undefined) {
-                await global.put(id, { ...globalBlock, lastUsedAt: now });
+                await this.recordUse(global, id, globalBlock, now);
                 continue;
             }
             if (project !== undefined) {
                 const block = project.get(id);
                 if (block !== undefined)
-                    await project.put(id, { ...block, lastUsedAt: now });
+                    await this.recordUse(project, id, block, now);
+            }
+        }
+    }
+    /**
+     * 命中记账 + 自动升级（2026-09-15 静默记忆机制）：命中次数达阈值即自动打开常驻
+     * 注入——「被反复检索命中」是它值得每轮付费的唯一客观证据。统计性字段不 emit，
+     * 只有真的改变了注入状态才发 `memory/changed`。
+     */
+    async recordUse(table, id, block, now) {
+        const hitCount = (block.hitCount ?? 0) + 1;
+        const normalized = normalizeBlock(block);
+        // 人工设置过的（injectedAuto === false）双向豁免：既不被降级，也不被升级。
+        // 少了这一条，人手动关掉的记忆会在下次命中时被系统重新打开——用户唯一能
+        // 表达「不要这条常驻」的动作就失效了，而这与降级侧「人工决定优先」不对称。
+        const promote = normalized.status === 'approved'
+            && block.quarantined !== true
+            && block.injectedAuto !== false
+            // 模板永不注入（0.6.0）：prompt 记录连自动升级的资格都没有。少了这一条，
+            // 模板会因「经常被搜到」而升成常驻，把注入预算花在从不该进上下文的东西上。
+            && (block.kind ?? 'fact') !== 'prompt'
+            && !normalized.injected
+            && hitCount >= AUTO_INJECT_HITS;
+        const updated = {
+            ...block,
+            hitCount,
+            lastUsedAt: now,
+            ...promote ? { injected: true, injectedAuto: true } : {},
+        };
+        await table.put(id, updated);
+        if (promote)
+            this.ctx.emit('memory/changed', { operation: 'injected', id, injected: true });
+    }
+    // ── 查询日志与影响力统计（⑥ 2026-09-15）────────────────────────────────
+    /** 查询日志（惰性创建；位置见 {@link queryLogPath}）。 */
+    queryLogInstance;
+    queryLog() {
+        this.queryLogInstance ??= new QueryLog({ path: this.queryLogPath() });
+        return this.queryLogInstance;
+    }
+    /** 查询日志文件路径：与 `memory.json` 同目录（不落子目录）。 */
+    queryLogPath() {
+        return this.config.queryLogPath ?? join(this.config.globalRoot ?? globalRoot(), 'query-log.json');
+    }
+    /**
+     * 记录一次检索：查询文本（截断到 120 字符）+ 命中条数 + 时间。**失败绝不影响检索**——
+     * 日志是旁路证据，不是检索的一部分。模板库检索不进日志：`prompt_search` 复用同一条
+     * `search` 通道，但模板是文件库、不属于「记忆漏检」的观察面。
+     *
+     * 查询文本是新的明文落盘点，因此先过危险内容硬拦（与写入路径同一套规则）：命中就只记
+     * 规则名、不留原文——凭据不该因为「只是被搜了一下」而进另一个明文文件。
+     */
+    recordQuery(query, hits, filter) {
+        if (filter?.kind === 'prompt')
+            return;
+        try {
+            const verdict = detectSensitive(query);
+            this.queryLog().appendQuery(verdict.quarantined
+                ? { query: `[已脱敏：命中 ${verdict.reason ?? 'dangerous-content'}]`, hits }
+                : { query, hits });
+        }
+        catch (error) {
+            this.ctx.logger?.warn?.(`dsh-memory: 查询日志写入跳过：${String(error)}`);
+        }
+    }
+    /**
+     * 影响力统计（⑥ / 反例 5）：按来源聚合「写入量 / 被检索命中数 / 常驻注入数」。
+     * 只算 fact 记录（模板索引不是记忆），隔离记录不计（与 list 的默认口径一致：
+     * 它们不在流通里）。「被人工删除数」暂缺的原因见 `summarizeSources` 的注释。
+     */
+    async sourceStats(projectCwd) {
+        const records = await this.list({ kind: 'fact' }, projectCwd);
+        return summarizeSources(records.map(record => ({
+            ...record.source === undefined ? {} : { source: record.source },
+            hitCount: record.hitCount,
+            injected: record.injected,
+        })));
+    }
+    /**
+     * 低频反查（⑥，**只产出报告，不自动改写**）：拿「命中 0 的查询」与既有记忆反查，
+     * 给出「本应命中却没命中」的候选，供人工或模型补 keywords。
+     *
+     * 不做自动补写：判断「这条记忆是否真该被那个查询找到」需要 LLM 语义判断，插件只提供
+     * 证据（候选为空即知识缺口——「这类知识你还没有」本身也是有用信息）。调用时机由人
+     * 或模型定，不在检索路径上、不产生每轮成本。
+     *
+     * @param projectCwd - 会话工作区；候选库连工作区记忆一起取。
+     * @param limit - 最多反查几个空命中查询（按最近出现排序）。
+     */
+    async suggestKeywordGaps(projectCwd, limit = 10) {
+        const summary = summarizeQueryLog(this.queryLog().readLog(), limit);
+        if (summary.gaps.length === 0)
+            return { logSize: summary.total, misses: summary.misses, gaps: [] };
+        const records = await this.list({ kind: 'fact' }, projectCwd);
+        const byId = new Map(records.map(record => [String(record.id), record]));
+        const docs = records.map(record => ({
+            id: String(record.id),
+            body: record.content,
+            tags: record.keywords.join(' '),
+        }));
+        return {
+            logSize: summary.total,
+            misses: summary.misses,
+            gaps: summary.gaps.map(gap => ({
+                query: gap.query,
+                count: gap.count,
+                lastAt: gap.lastAt,
+                candidates: rankGapCandidates(gap.query, docs).flatMap(candidate => {
+                    const record = byId.get(candidate.id);
+                    return record === undefined ? [] : [{
+                            id: candidate.id,
+                            excerpt: record.content.slice(0, GAP_EXCERPT_CHARS),
+                            keywords: record.keywords,
+                            exact: candidate.exact,
+                            relaxed: candidate.relaxed,
+                        }];
+                }),
+            })),
+        };
+    }
+    /**
+     * 长期未命中的自动降级（2026-09-15 淘汰机制）：**只撤自动开的常驻注入**——人工开
+     * 的开关不会被时间悄悄关掉（那是人的决定，不是信号的结论）。判定用 lastUsedAt，
+     * 从未命中过则回退 updatedAt。会话启动时调一次即可（见 index.ts 的预热路径）。
+     *
+     * @param projectCwd - 会话工作区；给了就连工作区表一起扫。
+     * @param now - 当前时间（测试注入用）。
+     * @returns 被撤下的条数（诊断与日志用）。
+     */
+    async demoteStale(projectCwd, now = Date.now()) {
+        return this.writeScope(projectCwd, () => this.demoteStaleInner(projectCwd, now));
+    }
+    /** {@link demoteStale} 的实现体；必须经 `writeScope` 进入。 */
+    async demoteStaleInner(projectCwd, now = Date.now()) {
+        const threshold = now - AUTO_DEMOTE_DAYS * 24 * 60 * 60 * 1000;
+        const tables = [this.requireTable('global')];
+        if (projectCwd !== undefined && projectCwd !== '') {
+            const project = await this.projectTableFor(projectCwd);
+            if (project !== undefined)
+                tables.push(project);
+        }
+        let demoted = 0;
+        for (const table of tables) {
+            // 先快照键值对：put 会改到底层 Map，边遍历边写不安全
+            for (const [id, block] of [...table.entries()]) {
+                if (block.injectedAuto !== true)
+                    continue;
+                if (block.quarantined === true)
+                    continue;
+                if (normalizeBlock(block).status !== 'approved')
+                    continue;
+                const last = block.lastUsedAt ?? block.updatedAt;
+                if (last > threshold)
+                    continue;
+                await table.put(id, { ...block, injected: false, injectedAuto: false });
+                this.ctx.emit('memory/changed', { operation: 'injected', id: MemoryId(id), injected: false });
+                demoted += 1;
             }
         }
+        return demoted;
+    }
+    /**
+     * 锚点批量校验（2026-09-15）：会话启动时调一次，把失效的条目标成 `stale`。
+     *
+     * 失效同时**撤掉常驻注入**——内容可能已经错了，继续每轮注入就是在误导（反例 2 的
+     * 教训）；但**不删除、也不排除检索**，它在结果里带标注，等模型核对后回写。
+     * 探测不到（`undefined`）按「未校验」处理，不动任何状态。
+     *
+     * @param probes - 探测上下文（工具清单 / 自身版本 / env 读取器）。
+     * @param projectCwd - 会话工作区；给了就连工作区表一起校验。
+     * @returns 本次状态发生变化的条数。
+     */
+    async verifyAnchors(probes, projectCwd) {
+        return this.writeScope(projectCwd, () => this.verifyAnchorsInner(probes, projectCwd));
+    }
+    /** {@link verifyAnchors} 的实现体；必须经 `writeScope` 进入。 */
+    async verifyAnchorsInner(probes, projectCwd) {
+        const tables = [this.requireTable('global')];
+        if (projectCwd !== undefined && projectCwd !== '') {
+            const project = await this.projectTableFor(projectCwd);
+            if (project !== undefined)
+                tables.push(project);
+        }
+        let changed = 0;
+        for (const table of tables) {
+            for (const [id, block] of [...table.entries()]) {
+                if (block.anchor === undefined)
+                    continue;
+                const holds = anchorHolds(block.anchor, probes);
+                if (holds === undefined)
+                    continue; // 未校验：探测不到就不动
+                if ((block.stale === true) === !holds)
+                    continue; // 状态没变
+                const label = `${block.anchor.kind}${block.anchor.name === undefined ? '' : `:${block.anchor.name}`}`;
+                const updated = holds
+                    ? { ...block, stale: false, staleReason: undefined }
+                    : {
+                        ...block,
+                        stale: true,
+                        staleReason: `${label} 声明为 ${block.anchor.value}，当前不符`,
+                        injected: false,
+                        injectedAuto: false,
+                    };
+                await table.put(id, updated);
+                this.ctx.emit('memory/changed', { operation: 'status', id: MemoryId(id), status: normalizeBlock(updated).status });
+                changed += 1;
+            }
+        }
+        return changed;
+    }
+    /**
+     * 旧数据迁移（2026-09-15 静默记忆机制）：一次性、幂等，会话启动维护时调用。
+     *
+     * 旧语义里 `suggested` 是「等人工审核」，新语义里它只剩「隔离」与「人工回退」两种含义——
+     * 不迁移的话那些记录会永久卡住：既不注入，也没人去放行。迁移逐条过危险内容检测：
+     * 安全则升 `approved`（写入即生效），命中则标 `quarantined` 进隔离（**必须先检测再放行**：
+     * 历史条目若含密钥，直接放行等于让它开始进注入）。
+     *
+     * 另外把「有 `lastUsedAt` 但无 `hitCount`」的老记录回填 `hitCount = 1`——它们可能早已被
+     * 反复用过，不该从零开始攒两次命中。旧 `injected: true` 且无 `injectedAuto` 的一律不动：
+     * 那是人工决定，不该被自动降级。
+     *
+     * @param projectCwd - 会话工作区；给了就连工作区表一起迁移。
+     * @returns 迁移统计（放行 / 隔离 / 回填计数）。
+     */
+    async migrateLegacy(projectCwd) {
+        return this.writeScope(projectCwd, () => this.migrateLegacyInner(projectCwd));
+    }
+    /** {@link migrateLegacy} 的实现体；必须经 `writeScope` 进入。 */
+    async migrateLegacyInner(projectCwd) {
+        const tables = [this.requireTable('global')];
+        if (projectCwd !== undefined && projectCwd !== '') {
+            const project = await this.projectTableFor(projectCwd);
+            if (project !== undefined)
+                tables.push(project);
+        }
+        const stats = { approved: 0, quarantined: 0, counted: 0 };
+        // 幂等：先判断是否真的有事可做——没有就直接返回，连备份都不做（否则每天首次启动
+        // 都会留下一份无意义的 .bak）
+        const needsMigration = tables.some(table => [...table.entries()].some(([, block]) => {
+            const normalized = normalizeBlock(block);
+            if (normalized.status === 'suggested' && block.quarantined !== true)
+                return true;
+            return block.hitCount === undefined && block.lastUsedAt !== undefined;
+        }));
+        if (!needsMigration)
+            return stats;
+        // 迁移前备份全局存储（工作区记忆随 git 分享，有 git 兜底）。备份失败只记日志、不阻断：
+        // 迁移本身就是幂等的，最坏情况是重复跑一次。
+        try {
+            const file = join(this.config.globalRoot ?? globalRoot(), 'memory.json');
+            if (existsSync(file)) {
+                const backup = `${file}.bak-${new Date().toISOString().slice(0, 10)}-migration`;
+                if (!existsSync(backup))
+                    writeFileSync(backup, readFileSync(file));
+            }
+        }
+        catch (error) {
+            this.ctx.logger?.warn?.(`dsh-memory: migration backup skipped: ${String(error)}`);
+        }
+        for (const table of tables) {
+            for (const [id, block] of [...table.entries()]) {
+                const normalized = normalizeBlock(block);
+                let updated;
+                // ① 旧的 suggested：安全则放行、危险则隔离
+                if (normalized.status === 'suggested' && block.quarantined !== true) {
+                    const verdict = detectSensitive(block.content, ...block.keywords);
+                    if (verdict.quarantined) {
+                        updated = {
+                            ...block,
+                            status: 'suggested',
+                            injected: false,
+                            quarantined: true,
+                            ...verdict.reason === undefined ? {} : { quarantineReason: verdict.reason },
+                        };
+                        stats.quarantined += 1;
+                    }
+                    else {
+                        updated = { ...block, status: 'approved', injected: normalized.injected };
+                        stats.approved += 1;
+                    }
+                }
+                // ② 命中计数回填（在 ① 的结果之上叠加，避免两次 put 互相覆盖）
+                const base = updated ?? block;
+                if (base.hitCount === undefined && base.lastUsedAt !== undefined) {
+                    updated = { ...base, hitCount: 1 };
+                    stats.counted += 1;
+                }
+                if (updated !== undefined)
+                    await table.put(id, updated);
+            }
+        }
+        return stats;
     }
     async forget(id, projectCwd) {
+        return this.writeScope(projectCwd, () => this.forgetInner(id, projectCwd));
+    }
+    /** {@link forget} 的实现体；必须经 `writeScope` 进入。 */
+    async forgetInner(id, projectCwd) {
         if (await this.requireTable('global').delete(id)) {
             this.ctx.emit('memory/changed', { operation: 'forgotten', id });
             return true;
@@ -387,6 +894,10 @@ export class MemoryEngine extends Service {
         return false;
     }
     async setStatus(id, status, projectCwd) {
+        return this.writeScope(projectCwd, () => this.setStatusInner(id, status, projectCwd));
+    }
+    /** {@link setStatus} 的实现体；必须经 `writeScope` 进入。 */
+    async setStatusInner(id, status, projectCwd) {
         const global = this.requireTable('global').get(id);
         if (global !== undefined) {
             const updated = {
@@ -394,6 +905,8 @@ export class MemoryEngine extends Service {
                 status,
                 // 旧数据可能缺 injected，写回时补全（读时迁移值）
                 injected: normalizeBlock(global).injected,
+                // 人工放行 = 审核通过并解除隔离（2026-09-15）
+                ...status === 'approved' ? { quarantined: false, quarantineReason: undefined } : {},
                 updatedAt: Date.now(),
             };
             await this.requireTable('global').put(id, updated);
@@ -409,6 +922,7 @@ export class MemoryEngine extends Service {
                     ...block,
                     status,
                     injected: normalizeBlock(block).injected,
+                    ...status === 'approved' ? { quarantined: false, quarantineReason: undefined } : {},
                     updatedAt: Date.now(),
                 };
                 await project.put(id, updated);
@@ -424,6 +938,10 @@ export class MemoryEngine extends Service {
      * 「常驻注入」开关调用（remote.setInjected）。
      */
     async setInjected(id, injected, projectCwd) {
+        return this.writeScope(projectCwd, () => this.setInjectedInner(id, injected, projectCwd));
+    }
+    /** {@link setInjected} 的实现体；必须经 `writeScope` 进入。 */
+    async setInjectedInner(id, injected, projectCwd) {
         const locate = async () => {
             const global = this.requireTable('global').get(id);
             if (global !== undefined)
@@ -443,10 +961,16 @@ export class MemoryEngine extends Service {
         if ((found.block.kind ?? 'fact') === 'prompt') {
             throw new Error(`cannot set injected of prompt record '${id}': prompt templates are never injected`);
         }
+        // 隔离记录不可注入（2026-09-15）：先放行（setStatus approved）再开开关
+        if (injected && found.block.quarantined === true) {
+            throw new Error(`cannot inject quarantined memory '${id}': approve it first`);
+        }
         const updated = {
             ...found.block,
             status: normalizeBlock(found.block).status,
             injected,
+            // 人工设置过即接管：此后既不被「长期未命中」自动降级，也不被「反复命中」自动升级（2026-09-15）
+            injectedAuto: false,
             updatedAt: Date.now(),
         };
         await found.table.put(id, updated);
@@ -455,19 +979,32 @@ export class MemoryEngine extends Service {
         return record;
     }
     /**
-     * 修改一条记忆的内容/关键词（0.3.1 整理记忆用）。内容被模型改动后
-     * 必须重新人工审核：status 重置为 suggested（自然停止注入——注入仅对
-     * approved 生效）；injected 保留原值（审核通过后注入开关原样恢复）。
+     * 修改一条记忆的内容/关键词（0.3.1 整理记忆用）。2026-09-15 起：改动**不再**
+     * 退回待审核——静默机制下记忆由系统与模型自行维护，更新即保持原有审核状态；
+     * `injected` 保留原值。若新内容命中危险规则则转为隔离（与写入路径同一判定）。
      */
     async update(id, patch, projectCwd) {
+        return this.writeScope(projectCwd, () => this.updateInner(id, patch, projectCwd));
+    }
+    /** {@link update} 的实现体；必须经 `writeScope` 进入。 */
+    async updateInner(id, patch, projectCwd) {
         const applyPatch = (block) => {
             const normalized = normalizeBlock(block);
+            const content = patch.content ?? block.content;
+            const keywords = patch.keywords === undefined
+                ? block.keywords
+                : patch.keywords.map(keyword => keyword.toLowerCase());
+            const verdict = detectSensitive(content, ...keywords);
             return {
                 ...block,
-                status: 'suggested',
+                // 命中危险规则：退回 suggested（不注入）+ 隔离（不检索）双保险；否则保持原状态
+                status: verdict.quarantined ? 'suggested' : normalized.status,
                 injected: normalized.injected,
+                ...verdict.quarantined
+                    ? { quarantined: true, ...verdict.reason === undefined ? {} : { quarantineReason: verdict.reason } }
+                    : { quarantined: false, quarantineReason: undefined },
                 ...(patch.content === undefined ? {} : { content: patch.content }),
-                ...(patch.keywords === undefined ? {} : { keywords: patch.keywords.map(keyword => keyword.toLowerCase()) }),
+                ...(patch.keywords === undefined ? {} : { keywords }),
                 updatedAt: Date.now(),
             };
         };
@@ -476,7 +1013,7 @@ export class MemoryEngine extends Service {
             const updated = applyPatch(global);
             await this.requireTable('global').put(id, updated);
             const record = toRecord(id, updated);
-            this.ctx.emit('memory/changed', { operation: 'status', id, status: 'suggested' });
+            this.ctx.emit('memory/changed', { operation: 'status', id, status: normalizeBlock(updated).status });
             return record;
         }
         const project = await this.projectTableFor(projectCwd);
@@ -486,7 +1023,7 @@ export class MemoryEngine extends Service {
                 const updated = applyPatch(block);
                 await project.put(id, updated);
                 const record = toRecord(id, updated);
-                this.ctx.emit('memory/changed', { operation: 'status', id, status: 'suggested' });
+                this.ctx.emit('memory/changed', { operation: 'status', id, status: normalizeBlock(updated).status });
                 return record;
             }
         }
@@ -502,6 +1039,8 @@ export class MemoryEngine extends Service {
         if (this.projectTables.has(key))
             return;
         await this.projectTableFor(key);
+        // 会话内首次打开工作区表时做一次启动维护（迁移 / 降级 / 锚点校验，2026-09-15）
+        await this.runMaintenanceOnce(projectCwd);
     }
     /**
      * 注入专用（0.3.4 + 0.5.1）：system prompt 的 `memory:recall` context
@@ -511,7 +1050,12 @@ export class MemoryEngine extends Service {
      * （`ensureProjectOpen` 提供预热，工具/面板路径也会打开）。
      */
     recallRecords(projectCwd) {
-        const injected = (table) => this.recordsOf(table).filter(record => record.status === 'approved' && record.injected);
+        const injected = (table) => 
+        // 模板永不注入（0.6.0）：这一条是兜底——即使存储里出现被标了 injected 的 prompt
+        // 记录（旧版本或人工改文件留下的），也不让它进上下文。
+        this.recordsOf(table).filter(record => record.status === 'approved'
+            && record.injected
+            && (record.kind ?? 'fact') !== 'prompt');
         const global = injected(this.requireTable('global'));
         if (projectCwd === undefined || projectCwd === '')
             return global;