dsh-prime-memory 0.16.1-beta.1 → 0.16.2

package/dist/store/occupancy.js

@@ -11,7 +11,8 @@
  */
 import * as path from 'node:path';
 import { errDetail } from '../util/filelog.js';
-import { atomicWriteJson, ensureDir, readJsonIfExists } from '../util/io.js';
+import { ensureDir, readJsonStrict, rmwJson } from '../util/io.js';
+import { OCCUPANCY_FILE_VERSION } from './file-versions.js';
 /** 会话条目上限(按 updatedAt 淘汰最旧;防文件无限增长)。 */
 export const OCCUPANCY_SESSION_CAP = 200;
 /** 条目过期清理(90 天未更新即丢弃,与 session-modes/dedupe 同款量级)。 */
@@ -21,6 +22,11 @@ export class OccupancyStore {
     file;
     entries = new Map();
     persistFailed = false;
+    /** 只读降级原因(undefined = 正常):非空时内存账目照常有效,但停止回写。 */
+    degraded;
+    degradedLogged = false;
+    /** 本进程上次成功写入的磁盘内容(紧凑 JSON);并发冲突判据:磁盘与它不同 = 别人写过。 */
+    lastPersisted;
     /** 串行化持久化写(避免并发原子写撞临时文件名);init 链最前(先载入再落盘,防丢更新)。 */
     writeChain;
     constructor(dataDir, logger) {
@@ -28,9 +34,34 @@ export class OccupancyStore {
         this.file = path.join(dataDir, 'occupancy.json');
         this.writeChain = this.init();
     }
-    /** 载入持久化账目(合并进内存——构造与载入之间发生的 save 不丢);失败降级内存态。 */
+    /**
+     * 载入持久化账目(合并进内存——构造与载入之间发生的 save 不丢);失败降级内存态。
+     *
+     * **读侧分类**(文件层加固 T2):缺失合法;损坏/不可读 → 告警 + 只读降级(禁写);
+     * 未知版本 → **仍按当前形状读取** + 只读降级(本 store 无迁移路径)。
+     */
     async init() {
-        const data = await readJsonIfExists(this.file);
+        const r = await readJsonStrict(this.file, { expectedVersion: OCCUPANCY_FILE_VERSION });
+        let data;
+        if (r.ok) {
+            data = r.value;
+        }
+        else if (r.reason === 'missing') {
+            return;
+        }
+        else {
+            const lenient = await readJsonStrict(this.file);
+            if (!lenient.ok) {
+                this.degraded = lenient.reason;
+                this.logger?.warn(`[memory] 记忆占用文件${lenient.reason === 'corrupt' ? '损坏' : '不可读'}(${this.file}): ` +
+                    `按空账目起步且**不回写**,原文件已保留${lenient.detail ? ` — ${lenient.detail}` : ''}`);
+                return;
+            }
+            data = lenient.value;
+            this.degraded = `未知版本(${lenient.version ?? '无 version 字段'})`;
+            this.logger?.warn(`[memory] 记忆占用文件版本未知(${lenient.version ?? '无'}):按当前形状读取并进入只读降级(不回写)`);
+        }
+        this.lastPersisted = JSON.stringify(data);
         if (!data?.sessions || typeof data.sessions !== 'object')
             return;
         const now = Date.now();
@@ -92,9 +123,25 @@ export class OccupancyStore {
         return this.writeChain;
     }
     async persist() {
+        if (this.degraded !== undefined) {
+            // 只读降级:内存账目照常有效(指示器不看磁盘),但不落盘
+            if (!this.degradedLogged) {
+                this.degradedLogged = true;
+                this.logger?.warn(`[memory] 记忆占用处于只读降级(${this.degraded}),已停止回写(磁盘文件保持不变)`);
+            }
+            return;
+        }
         try {
             await ensureDir(path.dirname(this.file));
-            await atomicWriteJson(this.file, this.serialize());
+            await rmwJson(this.file, async (cur) => {
+                const diskRaw = cur.ok ? JSON.stringify(cur.value) : undefined;
+                if (this.lastPersisted !== undefined && diskRaw !== undefined && diskRaw !== this.lastPersisted) {
+                    throw new Error(`记忆占用文件已被其它进程更新,本次写入已取消以避免覆盖;请重试该操作`);
+                }
+                const next = this.serialize();
+                this.lastPersisted = JSON.stringify(next);
+                return { next, result: undefined };
+            }, { logger: this.logger, purpose: 'occupancy-rmw' });
             this.persistFailed = false;
         }
         catch (err) {
@@ -129,6 +176,6 @@ export class OccupancyStore {
                 continue; // 归零条目不落盘
             sessions[sid] = { ...e };
         }
-        return { version: 1, sessions };
+        return { version: OCCUPANCY_FILE_VERSION, sessions };
     }
 }

package/dist/store/pending.d.ts

@@ -18,10 +18,16 @@ export type WarmupState = Record<ExtractMode, number>;
 export declare function freshWarmup(): WarmupState;
 export declare function emptyPending(): PendingBuckets;
 /** 读取缓冲文件:文件缺失/损坏 → 空桶(不抛出——丢了缓冲 L0 事实源仍在)。
- *  旧格式条目(无 sessionId)归 legacy 组;warmup 缺省 = 全新起步。 */
+ *  旧格式条目(无 sessionId)归 legacy 组;warmup 缺省 = 全新起步。
+ *
+ * **读侧分类**(文件层加固 T2):`missing` 与 `corrupt`/`unreadable` 区分(本函数是
+ * 全仓最早做到这点的一处,现在改用统一的 `readJsonStrict`)。
+ * **版本**(T3.5):`version` 非 1 时**允许读**(缓冲丢了只是少蒸馏一轮)但置
+ * `degraded`——调用方据此**禁止回写**,免得按旧解释覆盖新格式。 */
 export declare function loadPending(file: string, logger?: MemoryLogger): Promise<{
     buckets: PendingBuckets;
     warmup: WarmupState;
+    degraded?: string;
 }>;
 /** 按会话分组(会话切片):组按首条时间排序、组内按时间稳定排序——
  *  蒸馏的一切触发都以切片为单位,切片内永不跨会话混装(ADR-0003)。 */

package/dist/store/pending.js

@@ -5,9 +5,9 @@
  *
  * 与 state.json / session-modes.json 同款原子写;读取宽容(坏行丢弃、坏文件空桶起步)。
  */
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { atomicWriteJson } from '../util/io.js';
+import { atomicWriteJson, readJsonStrict } from '../util/io.js';
+import { PENDING_FILE_VERSION } from './file-versions.js';
 /** 旧格式(无 sessionId 字段)条目加载时归属的会话组。 */
 export const LEGACY_SESSION = 'legacy';
 /** 全新起步:三档都从 1 爬坡(首轮即触发抽取)。 */
@@ -24,24 +24,29 @@ function isMessage(m) {
     return typeof r.id === 'string' && typeof r.content === 'string' && (r.role === 'user' || r.role === 'assistant');
 }
 /** 读取缓冲文件:文件缺失/损坏 → 空桶(不抛出——丢了缓冲 L0 事实源仍在)。
- *  旧格式条目(无 sessionId)归 legacy 组;warmup 缺省 = 全新起步。 */
+ *  旧格式条目(无 sessionId)归 legacy 组;warmup 缺省 = 全新起步。
+ *
+ * **读侧分类**(文件层加固 T2):`missing` 与 `corrupt`/`unreadable` 区分(本函数是
+ * 全仓最早做到这点的一处,现在改用统一的 `readJsonStrict`)。
+ * **版本**(T3.5):`version` 非 1 时**允许读**(缓冲丢了只是少蒸馏一轮)但置
+ * `degraded`——调用方据此**禁止回写**,免得按旧解释覆盖新格式。 */
 export async function loadPending(file, logger) {
     const out = emptyPending();
-    // 直接读文件而非 readJsonIfExists:后者把"不存在"、"不可读"、"JSON 损坏"压成同一个 undefined,
-    // 会让形状/内容损坏静默降级为空桶(与"合法空 pending"不可区分)。此处区分 ENOENT(正常)与其余(需告警)。
-    let raw;
-    try {
-        raw = JSON.parse(await fs.readFile(file, 'utf-8'));
+    const r = await readJsonStrict(file);
+    if (!r.ok) {
+        if (r.reason === 'missing')
+            return { buckets: out, warmup: freshWarmup() };
+        logger?.warn(`[memory] 未蒸馏缓冲${r.reason === 'corrupt' ? '文件损坏' : '不可读'}(按空桶起步): ${file}${r.detail ? ` — ${r.detail}` : ''}`);
+        return { buckets: out, warmup: freshWarmup(), degraded: r.reason };
     }
-    catch (err) {
-        if (err?.code !== 'ENOENT') {
-            logger?.warn(`[memory] 未蒸馏缓冲读取失败(按空桶起步): ${file} — ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return { buckets: out, warmup: freshWarmup() };
+    const raw = r.value;
+    const degraded = r.version !== undefined && r.version !== PENDING_FILE_VERSION ? `未知版本(${r.version})` : undefined;
+    if (degraded !== undefined) {
+        logger?.warn(`[memory] 未蒸馏缓冲版本未知(${r.version}):按当前形状读取并进入只读降级(不回写)`);
     }
     if (!raw || typeof raw !== 'object' || !raw.buckets || typeof raw.buckets !== 'object') {
         logger?.warn(`[memory] 未蒸馏缓冲格式不符(缺 buckets,按空桶起步): ${file}`);
-        return { buckets: out, warmup: freshWarmup() };
+        return { buckets: out, warmup: freshWarmup(), ...(degraded ? { degraded } : {}) };
     }
     let dropped = 0;
     let legacy = 0;
@@ -74,7 +79,7 @@ export async function loadPending(file, logger) {
         if (typeof w === 'number' && Number.isFinite(w) && w >= 0)
             warmup[key] = Math.floor(w);
     }
-    return { buckets: out, warmup };
+    return { buckets: out, warmup, ...(degraded ? { degraded } : {}) };
 }
 /** 按会话分组(会话切片):组按首条时间排序、组内按时间稳定排序——
  *  蒸馏的一切触发都以切片为单位,切片内永不跨会话混装(ADR-0003)。 */
@@ -93,7 +98,7 @@ export function groupPendingBySession(messages) {
 }
 /** 全量原子落盘(每次蒸馏尝试后调用;桶有上限,量级为百条级)。 */
 export async function savePending(file, buckets, warmup) {
-    const payload = { version: 1, buckets, ...(warmup ? { warmup } : {}) };
+    const payload = { version: PENDING_FILE_VERSION, buckets, ...(warmup ? { warmup } : {}) };
     await atomicWriteJson(file, payload);
 }
 export function pendingPathFor(dataDir) {

package/dist/store/recall-dedupe.d.ts

@@ -8,10 +8,20 @@ export declare class RecallDedupeStore {
     private readonly file;
     private readonly entries;
     private persistFailed;
+    /** 只读降级原因(undefined = 正常):非空时去重集合照常生效,但停止回写。 */
+    private degraded;
+    private degradedLogged;
+    /** 本进程上次成功写入的磁盘内容(紧凑 JSON);并发冲突判据:磁盘与它不同 = 别人写过。 */
+    private lastPersisted;
     /** 串行化持久化写(避免并发原子写撞临时文件名);init 链最前(先载入再落盘,防丢更新)。 */
     private writeChain;
     constructor(dataDir: string, logger?: MemoryLogger | undefined);
-    /** 载入持久化映射(合并进内存——构造与载入之间发生的 mark 不丢);失败降级内存态。 */
+    /**
+     * 载入持久化映射(合并进内存——构造与载入之间发生的 mark 不丢);失败降级内存态。
+     *
+     * **读侧分类**(文件层加固 T2):缺失合法;损坏/不可读 → 告警 + 只读降级(禁写);
+     * 未知版本 → **仍按当前形状读取** + 只读降级(本 store 无迁移路径)。
+     */
     private init;
     /** 该会话的已注入集合(热路径同步读;未出现过的会话返回空集合,惰性建条)。 */
     seen(sessionId: string): Set<string>;

package/dist/store/recall-dedupe.js

@@ -10,7 +10,8 @@
  */
 import * as path from 'node:path';
 import { errDetail } from '../util/filelog.js';
-import { atomicWriteJson, ensureDir, readJsonIfExists } from '../util/io.js';
+import { ensureDir, readJsonStrict, rmwJson } from '../util/io.js';
+import { RECALL_DEDUPE_FILE_VERSION } from './file-versions.js';
 /** 会话条目上限(按 updatedAt 淘汰最旧;防文件无限增长)。 */
 export const RECALL_DEDUPE_SESSION_CAP = 200;
 /** 单会话记录 id 上限(按插入序淘汰最旧;Set 迭代序即插入序)。 */
@@ -22,6 +23,11 @@ export class RecallDedupeStore {
     file;
     entries = new Map();
     persistFailed = false;
+    /** 只读降级原因(undefined = 正常):非空时去重集合照常生效,但停止回写。 */
+    degraded;
+    degradedLogged = false;
+    /** 本进程上次成功写入的磁盘内容(紧凑 JSON);并发冲突判据:磁盘与它不同 = 别人写过。 */
+    lastPersisted;
     /** 串行化持久化写(避免并发原子写撞临时文件名);init 链最前(先载入再落盘,防丢更新)。 */
     writeChain;
     constructor(dataDir, logger) {
@@ -29,9 +35,34 @@ export class RecallDedupeStore {
         this.file = path.join(dataDir, 'recall-dedupe.json');
         this.writeChain = this.init();
     }
-    /** 载入持久化映射(合并进内存——构造与载入之间发生的 mark 不丢);失败降级内存态。 */
+    /**
+     * 载入持久化映射(合并进内存——构造与载入之间发生的 mark 不丢);失败降级内存态。
+     *
+     * **读侧分类**(文件层加固 T2):缺失合法;损坏/不可读 → 告警 + 只读降级(禁写);
+     * 未知版本 → **仍按当前形状读取** + 只读降级(本 store 无迁移路径)。
+     */
     async init() {
-        const data = await readJsonIfExists(this.file);
+        const r = await readJsonStrict(this.file, { expectedVersion: RECALL_DEDUPE_FILE_VERSION });
+        let data;
+        if (r.ok) {
+            data = r.value;
+        }
+        else if (r.reason === 'missing') {
+            return;
+        }
+        else {
+            const lenient = await readJsonStrict(this.file);
+            if (!lenient.ok) {
+                this.degraded = lenient.reason;
+                this.logger?.warn(`[memory] 召回去重文件${lenient.reason === 'corrupt' ? '损坏' : '不可读'}(${this.file}): ` +
+                    `按空集合起步且**不回写**,原文件已保留${lenient.detail ? ` — ${lenient.detail}` : ''}`);
+                return;
+            }
+            data = lenient.value;
+            this.degraded = `未知版本(${lenient.version ?? '无 version 字段'})`;
+            this.logger?.warn(`[memory] 召回去重文件版本未知(${lenient.version ?? '无'}):按当前形状读取并进入只读降级(不回写)`);
+        }
+        this.lastPersisted = JSON.stringify(data);
         if (!data?.sessions || typeof data.sessions !== 'object')
             return;
         const now = Date.now();
@@ -95,9 +126,25 @@ export class RecallDedupeStore {
         return this.writeChain;
     }
     async persist() {
+        if (this.degraded !== undefined) {
+            // 只读降级:内存去重集合照常生效(重复注入照样被压),但不落盘
+            if (!this.degradedLogged) {
+                this.degradedLogged = true;
+                this.logger?.warn(`[memory] 召回去重处于只读降级(${this.degraded}),已停止回写(磁盘文件保持不变)`);
+            }
+            return;
+        }
         try {
             await ensureDir(path.dirname(this.file));
-            await atomicWriteJson(this.file, this.serialize());
+            await rmwJson(this.file, async (cur) => {
+                const diskRaw = cur.ok ? JSON.stringify(cur.value) : undefined;
+                if (this.lastPersisted !== undefined && diskRaw !== undefined && diskRaw !== this.lastPersisted) {
+                    throw new Error(`召回去重文件已被其它进程更新,本次写入已取消以避免覆盖;请重试该操作`);
+                }
+                const next = this.serialize();
+                this.lastPersisted = JSON.stringify(next);
+                return { next, result: undefined };
+            }, { logger: this.logger, purpose: 'recall-dedupe-rmw' });
             this.persistFailed = false;
         }
         catch (err) {
@@ -133,6 +180,6 @@ export class RecallDedupeStore {
                 continue; // 空集合不落盘
             sessions[sid] = { recordIds: [...e.ids], updatedAt: e.updatedAt };
         }
-        return { version: 1, sessions };
+        return { version: RECALL_DEDUPE_FILE_VERSION, sessions };
     }
 }

package/dist/store/session-modes.d.ts

@@ -9,12 +9,23 @@ export declare class SessionModeStore {
     private readonly entries;
     private readonly loaded;
     private persistFailed;
+    /** 只读降级原因(undefined = 正常):非空时内存态照常生效,但停止回写。 */
+    private degraded;
+    private degradedLogged;
+    /** 本进程上次成功写入的磁盘内容(紧凑 JSON);并发冲突判据:磁盘与它不同 = 别人写过。 */
+    private lastPersisted;
     /** 档位切换回调(index.ts 装配 runner 的同步动作:切片落袋/挂起,ADR-0003)。 */
     private onModeChange?;
     /** 串行化持久化写(避免并发原子写撞临时文件名)。 */
     private writeChain;
     constructor(dataDir: string, defaultMode: Extract<MemoryMode, 'auto' | 'chat' | 'work'>, logger?: MemoryLogger | undefined);
-    /** 载入持久化映射(index.ts 启动时 await;失败降级内存态)。 */
+    /**
+     * 载入持久化映射(index.ts 启动时 await;失败降级内存态)。
+     *
+     * **读侧分类**(文件层加固 T2):缺失合法;损坏/不可读 → 告警 + 只读降级;
+     * 未知版本 → **仍按当前形状读取**(本 store 无迁移路径,一律拒载会让档位在
+     * 版本回退后全部失效)+ 只读降级(禁写)。
+     */
     init(): Promise<void>;
     get default(): MemoryMode;
     /** 同步读取:未设置过的会话返回默认档。 */

package/dist/store/session-modes.js

@@ -7,7 +7,8 @@
 import * as path from 'node:path';
 import { WING_CATALOG } from '../types.js';
 import { errDetail } from '../util/filelog.js';
-import { atomicWriteJson, ensureDir, readJsonIfExists } from '../util/io.js';
+import { ensureDir, readJsonStrict, rmwJson } from '../util/io.js';
+import { SESSION_MODES_FILE_VERSION } from './file-versions.js';
 const MODES = ['auto', 'chat', 'work', 'off'];
 const PRUNE_MS = 90 * 24 * 3600_000;
 const MAX_ENTRIES = 500;
@@ -25,6 +26,11 @@ export class SessionModeStore {
     entries = new Map();
     loaded;
     persistFailed = false;
+    /** 只读降级原因(undefined = 正常):非空时内存态照常生效,但停止回写。 */
+    degraded;
+    degradedLogged = false;
+    /** 本进程上次成功写入的磁盘内容(紧凑 JSON);并发冲突判据:磁盘与它不同 = 别人写过。 */
+    lastPersisted;
     /** 档位切换回调(index.ts 装配 runner 的同步动作:切片落袋/挂起,ADR-0003)。 */
     onModeChange;
     /** 串行化持久化写(避免并发原子写撞临时文件名)。 */
@@ -35,9 +41,35 @@ export class SessionModeStore {
         this.file = path.join(dataDir, 'session-modes.json');
         this.loaded = defaultMode;
     }
-    /** 载入持久化映射(index.ts 启动时 await;失败降级内存态)。 */
+    /**
+     * 载入持久化映射(index.ts 启动时 await;失败降级内存态)。
+     *
+     * **读侧分类**(文件层加固 T2):缺失合法;损坏/不可读 → 告警 + 只读降级;
+     * 未知版本 → **仍按当前形状读取**(本 store 无迁移路径,一律拒载会让档位在
+     * 版本回退后全部失效)+ 只读降级(禁写)。
+     */
     async init() {
-        const data = await readJsonIfExists(this.file);
+        const r = await readJsonStrict(this.file, { expectedVersion: SESSION_MODES_FILE_VERSION });
+        let data;
+        if (r.ok) {
+            data = r.value;
+        }
+        else if (r.reason === 'missing') {
+            return;
+        }
+        else {
+            const lenient = await readJsonStrict(this.file);
+            if (!lenient.ok) {
+                this.degraded = lenient.reason;
+                this.logger?.warn(`[memory] 会话档位文件${lenient.reason === 'corrupt' ? '损坏' : '不可读'}(${this.file}): ` +
+                    `按默认档起步且**不回写**,原文件已保留${lenient.detail ? ` — ${lenient.detail}` : ''}`);
+                return;
+            }
+            data = lenient.value;
+            this.degraded = `未知版本(${lenient.version ?? '无 version 字段'})`;
+            this.logger?.warn(`[memory] 会话档位文件版本未知(${lenient.version ?? '无'}):按当前形状读取并进入只读降级(不回写)`);
+        }
+        this.lastPersisted = JSON.stringify(data);
         if (!data?.sessions || typeof data.sessions !== 'object')
             return;
         const now = Date.now();
@@ -179,9 +211,25 @@ export class SessionModeStore {
         return this.writeChain;
     }
     async persist() {
+        if (this.degraded !== undefined) {
+            // 只读降级:内存态照常生效(切档在本次会话内有效),但不落盘
+            if (!this.degradedLogged) {
+                this.degradedLogged = true;
+                this.logger?.warn(`[memory] 会话档位处于只读降级(${this.degraded}),已停止回写(磁盘文件保持不变)`);
+            }
+            return;
+        }
         try {
             await ensureDir(path.dirname(this.file));
-            await atomicWriteJson(this.file, this.serialize());
+            await rmwJson(this.file, async (cur) => {
+                const diskRaw = cur.ok ? JSON.stringify(cur.value) : undefined;
+                if (this.lastPersisted !== undefined && diskRaw !== undefined && diskRaw !== this.lastPersisted) {
+                    throw new Error(`会话档位文件已被其它进程更新,本次写入已取消以避免覆盖;请重试该操作`);
+                }
+                const next = this.serialize();
+                this.lastPersisted = JSON.stringify(next);
+                return { next, result: undefined };
+            }, { logger: this.logger, purpose: 'session-modes-rmw' });
             this.persistFailed = false;
         }
         catch (err) {
@@ -214,6 +262,6 @@ export class SessionModeStore {
         const sessions = {};
         for (const [sid, e] of this.entries)
             sessions[sid] = e;
-        return { version: 1, sessions };
+        return { version: SESSION_MODES_FILE_VERSION, sessions };
     }
 }

package/dist/store/slots.d.ts

@@ -57,11 +57,22 @@ export declare class SlotStore {
     /** 活引用:数组本身稳定,元素原地改;外部持有者不会因 mutate 拿到孤儿。 */
     private slots;
     private rev;
+    /** 只读降级原因(undefined = 正常):非空时内存照常更新,但停止回写。 */
+    private degraded;
+    /** 本进程已认可的磁盘 rev(并发冲突判据:磁盘比它新 = 别人写过)。 */
+    private baseRev;
+    private degradedLogged;
     private readonly maxSlots;
     private readonly maxBodyChars;
     private readonly maxTitleChars;
     constructor(file: string, logger: MemoryLogger, opts?: Partial<SlotStoreOptions>);
-    /** 读回持久态;文件缺失/损坏时用默认空态,不抛错。 */
+    /**
+     * 读回持久态。**读侧分类**(文件层加固 T2):
+     * - 缺失 → 默认空态(首次运行,合法,不告警);
+     * - 损坏/不可读 → 默认空态 + **只读降级**(禁写,不覆盖原文件);
+     * - 未知版本 → **允许读**(按当前形状宽容解释)+ 只读降级(禁写)。
+     *   本 store 无迁移路径,一律拒载会让插件在版本回退时直接不可用。
+     */
     load(): Promise<void>;
     /** 同步读内存,返回副本(不泄漏内部数组)。 */
     list(): Slot[];
@@ -102,7 +113,14 @@ export declare class SlotStore {
         openCount: number;
         slots: SlotView[];
     };
-    /** 原子写盘 + rev 单调递增。 */
+    /**
+     * 锁内 RMW 写盘 + rev 单调递增(文件层加固 T4.7)。
+     *
+     * `rev` 在这里多担一个职责:**并发冲突判据**。锁保证"读-算-写"不交错,
+     * 但本进程的内存态仍可能是旧的(别人在我上次读之后写过)——比较磁盘 rev 与
+     * `baseRev` 能发现这件事,此时**拒绝写入**并让调用方看到失败,而不是把别人的
+     * 更新整块盖掉(丢更新)或假装成功。
+     */
     private persist;
     static pathFor(dataDir: string): string;
 }

package/dist/store/slots.js

@@ -11,7 +11,8 @@
  */
 import * as path from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { atomicWriteJson, readJsonIfExists, nowIso } from '../util/io.js';
+import { readJsonStrict, rmwJson, nowIso } from '../util/io.js';
+import { SLOTS_FILE_VERSION } from './file-versions.js';
 /**
  * 槽位类型全集。**单一所有者**:投影片注册的 schema 校验也从这里取枚举,
  * 避免"store 加了新 kind、投影 schema 没跟上"导致 drive 期 parse 抛错。
@@ -89,6 +90,11 @@ export class SlotStore {
     /** 活引用:数组本身稳定,元素原地改;外部持有者不会因 mutate 拿到孤儿。 */
     slots = [];
     rev = 0;
+    /** 只读降级原因(undefined = 正常):非空时内存照常更新,但停止回写。 */
+    degraded;
+    /** 本进程已认可的磁盘 rev(并发冲突判据:磁盘比它新 = 别人写过)。 */
+    baseRev = 0;
+    degradedLogged = false;
     maxSlots;
     maxBodyChars;
     maxTitleChars;
@@ -99,14 +105,39 @@ export class SlotStore {
         this.maxBodyChars = opts.maxBodyChars ?? 512;
         this.maxTitleChars = opts.maxTitleChars ?? 60;
     }
-    /** 读回持久态;文件缺失/损坏时用默认空态,不抛错。 */
+    /**
+     * 读回持久态。**读侧分类**(文件层加固 T2):
+     * - 缺失 → 默认空态(首次运行,合法,不告警);
+     * - 损坏/不可读 → 默认空态 + **只读降级**(禁写,不覆盖原文件);
+     * - 未知版本 → **允许读**(按当前形状宽容解释)+ 只读降级(禁写)。
+     *   本 store 无迁移路径,一律拒载会让插件在版本回退时直接不可用。
+     */
     async load() {
-        const raw = await readJsonIfExists(this.file);
-        if (!raw)
+        const r = await readJsonStrict(this.file, { expectedVersion: SLOTS_FILE_VERSION });
+        let raw;
+        if (r.ok) {
+            raw = r.value;
+        }
+        else if (r.reason === 'missing') {
             return;
+        }
+        else {
+            // unknown_version 仍要读出内容(可用性优先),只是禁止回写
+            const lenient = await readJsonStrict(this.file);
+            if (!lenient.ok) {
+                this.degraded = lenient.reason;
+                this.logger.warn(`[memory] 槽位状态文件${lenient.reason === 'corrupt' ? '损坏' : '不可读'}(${this.file}): ` +
+                    `按空态起步且**不回写**,原文件已保留${lenient.detail ? ` — ${lenient.detail}` : ''}`);
+                return;
+            }
+            raw = lenient.value;
+            this.degraded = `未知版本(${lenient.version ?? '无 version 字段'})`;
+            this.logger.warn(`[memory] 槽位状态文件版本未知(${lenient.version ?? '无 version 字段'}):按当前形状读取并进入只读降级(不回写),避免用旧解释覆盖新文件`);
+        }
         const { slots, rev } = fromFile(raw);
         this.slots = slots;
         this.rev = rev;
+        this.baseRev = rev;
     }
     /** 同步读内存,返回副本(不泄漏内部数组)。 */
     list() {
@@ -235,12 +266,54 @@ export class SlotStore {
             })),
         };
     }
-    /** 原子写盘 + rev 单调递增。 */
+    /**
+     * 锁内 RMW 写盘 + rev 单调递增(文件层加固 T4.7)。
+     *
+     * `rev` 在这里多担一个职责:**并发冲突判据**。锁保证"读-算-写"不交错,
+     * 但本进程的内存态仍可能是旧的(别人在我上次读之后写过)——比较磁盘 rev 与
+     * `baseRev` 能发现这件事,此时**拒绝写入**并让调用方看到失败,而不是把别人的
+     * 更新整块盖掉(丢更新)或假装成功。
+     */
     async persist() {
-        this.rev += 1;
-        const file = { version: 1, rev: this.rev, slots: this.slots };
+        if (this.degraded !== undefined) {
+            // 只读降级:内存态照常更新(工具语义不受影响),但绝不落盘——
+            // 此刻内存里是"按当前形状解释"的结果,写回去会把磁盘上的新格式洗成旧格式。
+            if (!this.degradedLogged) {
+                this.degradedLogged = true;
+                this.logger.warn(`[memory] 槽位处于只读降级(${this.degraded}),已停止回写(磁盘文件保持不变)`);
+            }
+            return;
+        }
         try {
-            await atomicWriteJson(this.file, file);
+            await rmwJson(this.file, async (cur) => {
+                const disk = cur.ok ? cur.value : undefined;
+                const diskRev = disk && typeof disk.rev === 'number' && disk.rev >= 0 ? disk.rev : 0;
+                if (diskRev > this.baseRev) {
+                    // 别人写过。槽位是**独立条目集合**(相互无引用、无计数),合并没有歧义:
+                    // 以磁盘为底、本进程的同 id 条目覆盖之(内存态更新),于是两边的新增都留下。
+                    // 直接拒写虽然"可观测",但会让并发场景下的新增静默消失——能合并就别丢。
+                    const merged = new Map();
+                    for (const s of (disk?.slots ?? []))
+                        merged.set(s.id, s);
+                    for (const s of this.slots)
+                        merged.set(s.id, s); // 本进程优先
+                    if (merged.size > this.maxSlots) {
+                        this.logger.warn(`[memory] 槽位合并后超过上限(${merged.size} > ${this.maxSlots}),保留本进程优先的前 ${this.maxSlots} 条`);
+                        const keep = new Set(this.slots.map((s) => s.id));
+                        const trimmed = [...merged.values()].filter((s) => keep.has(s.id)).slice(0, this.maxSlots);
+                        merged.clear();
+                        for (const s of trimmed)
+                            merged.set(s.id, s);
+                    }
+                    this.slots = [...merged.values()];
+                    this.rev = diskRev + 1;
+                    this.baseRev = this.rev;
+                    return { next: { version: SLOTS_FILE_VERSION, rev: this.rev, slots: this.slots }, result: undefined };
+                }
+                this.rev = Math.max(this.rev, diskRev) + 1;
+                this.baseRev = this.rev;
+                return { next: { version: SLOTS_FILE_VERSION, rev: this.rev, slots: this.slots }, result: undefined };
+            }, { logger: this.logger, purpose: 'slots-rmw' });
         }
         catch (err) {
             // 写盘失败只告警,不阻断调用方(降级:内存态已更新,下次写会重试)

package/dist/store/state.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryFamily } from '../types.js';
+import type { MemoryFamily, MemoryLogger } from '../types.js';
 export interface MemoryState {
     /** 上次 L1 抽取时间(epoch ms)。 */
     lastExtractAt: number;
@@ -22,9 +22,22 @@ export interface MemoryState {
 export declare function defaultState(): MemoryState;
 export declare class StateStore {
     private readonly file;
+    private readonly logger?;
     private buckets;
     private migrated;
-    constructor(file: string);
+    /** 只读降级原因(非空 = 拒绝加载且禁止回写)。 */
+    private degradedReason;
+    private saveBlockedLogged;
+    /** 本进程上次成功写入的磁盘内容(紧凑 JSON);并发冲突判据。 */
+    private lastPersisted;
+    constructor(file: string, logger?: MemoryLogger | undefined);
+    /**
+     * 只读降级原因(undefined = 正常)。
+     *
+     * 降级时 `forFamily` 仍返回默认空态——记忆功能继续可用(只是丢 checkpoint),
+     * 但**绝不回写**,以免把用户磁盘上那份读不懂/已损坏的文件洗掉。
+     */
+    get degraded(): string | undefined;
     load(): Promise<void>;
     /** v1 → v2 迁移发生时为 true(调用方记日志/落盘)。 */
     get didMigrate(): boolean;