dsh-lite-memory 0.17.0 → 0.18.19

package/test/control.test.mjs

@@ -57,7 +57,7 @@ const seedRule = (scope, title) => {
     const row = draft.entries.find((entry) => entry.id === id);
     row.origin = 'project_evolution';
     row.current.conditions = [{ key: 'seriesId', value: '口播' }];
-    row.maintenance.learning = { state: 'active' };
+    row.maintenance.learning = { state: 'active', specDigest: 'seeded' };
     return { changed: true };
   });
   return id;
@@ -95,7 +95,7 @@ const toggle = (scope, enabled) => store.setMemoryEnabled(scope, enabled, { oper
   const saved = await runtime.exec('memory_save', { title: '关闭后写入', summary: '应当拒绝', body: '不该落盘' }, agent);
   assert.equal(saved.changed, false);
   assert.equal(saved.reason, 'memory_disabled');
-  assert.equal(saved.id, '');
+  assert.equal(saved.id, undefined);
 }
 
 /* C02：关闭期间所有写入入口都拒绝，自进化不能绕过总开关打开。 */

package/test/crossing.test.mjs

@@ -10,7 +10,7 @@ const view = await import('../view.js');
 
 const {
   saveEntry, routeScope, visibleRules, move, resumeMove, movePending,
-  upsert, forget, readLinks, loadIndex, scopeOf, globalScope, readEntry,
+  upsert, forget, readLinks, loadIndex, scopeOf, globalScope, readEntry, pendingConflictsOf,
 } = store;
 
 let passed = 0;
@@ -369,4 +369,25 @@ await test('L06 展示视图不把关联结构塞给模型', () => {
 });
 
 for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true });
+
+// ── S12 冲突队列：相近只记待办，确认后才进库 ───────────────────────────────
+await test('S12 相近保存进待办队列，确认 distinct 后出队', () => {
+  const scope = fresh('conflict-queue');
+  saveEntry(globalScope(), { title: '发布前检查清单', summary: '发版前逐项确认', body: '清单', scope: 'global', resolution: 'distinct' });
+  assert.equal(pendingConflictsOf(globalScope()), 0);
+  const near = saveEntry(scope, { title: '发布前检查清单', summary: '发版前逐项确认（项目补充）', body: '项目清单' });
+  assert.equal(near.needsResolution, true);
+  assert.equal(near.pendingConflicts, 1);
+  assert.equal(pendingConflictsOf(scope), 1);
+  const queued = loadIndex(scope).conflicts[0];
+  assert.equal(queued.title, '发布前检查清单');
+  assert.equal(queued.scope, 'project');
+  assert.equal(queued.candidates.length >= 1, true);
+  const again = saveEntry(scope, { title: '发布前检查清单', summary: '发版前逐项确认（项目补充）', body: '项目清单' });
+  assert.equal(pendingConflictsOf(scope), 1);
+  const distinct = saveEntry(scope, { title: '发布前检查清单', summary: '发版前逐项确认（项目补充）', body: '项目清单', resolution: 'distinct' });
+  assert.equal(distinct.needsResolution, false);
+  assert.equal(pendingConflictsOf(scope), 0);
+});
+
 console.log(`crossing.test.mjs: ${passed} passed`);

package/test/eval-seed.test.mjs

@@ -0,0 +1,113 @@
+/**
+ * 30 条固定样本的召回基线：10 该召回、10 该拒绝、10 该等条件确认。
+ * 只断言行为（召回率 / 误触发 / 边界外泄），措辞取用户原话视角。
+ */
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+process.env.DSH_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-eval-'));
+const view = await import('../view.js');
+
+const base = (extra) => ({
+  status: 'active', applicability: 'all_in_scope', conditions: [], selection: null,
+  aliases: [], tags: [], triggers: [], when: '', lastUsed: '', ...extra,
+});
+
+const MEM = [
+  base({ id: 'mem_100000000001', title: '插件改完先试热刷新', summary: '热刷新不行再重启宿主', triggers: ['插件改完'] }),
+  base({ id: 'mem_100000000002', title: '发版前跑四条 lint', summary: '文案、中文排印、风格、检测器都要清零', triggers: ['发版'] }),
+  base({ id: 'mem_100000000003', title: '外链一律用绝对路径', summary: '聊天里的文件链接必须绝对路径，否则点开报 ENOENT' }),
+  base({ id: 'mem_100000000004', title: '截图只在看外观时用', summary: '判断页面对不对读文本树' }),
+  base({ id: 'mem_100000000005', title: '写盘先写临时文件再改名', summary: 'rename 之后 fsync 目录，避免半截文件' }),
+  base({ id: 'mem_100000000006', title: '客户端包上限四十 KiB', summary: 'gzip 之后超过就不许合入' }),
+  base({ id: 'mem_100000000007', title: '测试日志写到临时目录', summary: '长跑放后台，用 EXIT= 判断结果' }),
+  base({ id: 'mem_100000000008', title: '推送前先跑全量测试', summary: '绿了再 commit' }),
+  base({ id: 'mem_100000000009', title: '一次性脚本用完就删', summary: '这个脚本只跑一次，别留仓库里' }),
+  base({ id: 'mem_100000000010', title: '中文文案不用省略号收尾', summary: '能写完就写完' }),
+  base({
+    id: 'mem_100000000011', title: '部署前确认目标机器', summary: '只在目标机器上执行',
+    applicability: 'conditional', conditions: [{ key: 'taskKind', value: 'deploy' }],
+  }),
+  base({ id: 'mem_100000000012', title: '配色只沿用现有 token', summary: '不新造颜色', applicability: 'unresolved' }),
+];
+
+/** 10 条该召回：查询是真人会说的话，答案就在标题/关键词里。 */
+const RECALL = [
+  ['插件改完怎么让它生效？', '插件改完先试热刷新'],
+  ['发版之前要跑哪些检查？', '发版前跑四条 lint'],
+  ['聊天里给的文件链接怎么写？', '外链一律用绝对路径'],
+  ['判断页面报错要截图吗？', '截图只在看外观时用'],
+  ['写文件怎么保证不会写出半截？', '写盘先写临时文件再改名'],
+  ['客户端包大小有上限吗？', '客户端包上限四十 KiB'],
+  ['测试日志放哪里？', '测试日志写到临时目录'],
+  ['推送代码前要做什么？', '推送前先跑全量测试'],
+  ['临时脚本要留在仓库里吗？', '一次性脚本用完就删'],
+  ['中文文案末尾要加省略号吗？', '中文文案不用省略号收尾'],
+];
+
+/** 10 条该拒绝：字面上有常见词，但跟任何一条记忆都不相关。 */
+const REJECT = [
+  '把这段视频的字幕导出来',
+  '明早路过菜市场买点香菜',
+  '这个季节樱桃多少钱一斤',
+  '帮我把上周的照片按日期归类',
+  '厨房水槽下面有点漏水',
+  '地铁六号线末班车几点',
+  '明天杭州会下雨吗',
+  '给猫换一个更安静的猫砂盆',
+  '这本书的第二章讲什么',
+  '楼下咖啡店的营业时间',
+];
+
+/** 10 条该等条件：找到了，但适用条件还没确认，不许当已适用塞进上下文。 */
+const AWAIT = [
+  ['这台机器部署前要确认什么？', '部署前确认目标机器'],
+  ['部署脚本怎么跑？', '部署前确认目标机器'],
+  ['机器对不上能直接部署吗？', '部署前确认目标机器'],
+  ['新页面的配色怎么定？', '配色只沿用现有 token'],
+  ['这个组件能新造颜色吗？', '配色只沿用现有 token'],
+  ['界面上可以加渐变吗？', '配色只沿用现有 token'],
+  ['主题色改成什么了？', '配色只沿用现有 token'],
+  ['图标颜色跟着谁走？', '配色只沿用现有 token'],
+  ['按钮圆角用新的吗？', '配色只沿用现有 token'],
+  ['换肤要动哪些变量？', '配色只沿用现有 token'],
+];
+
+const titleOf = (row) => row.record.title;
+const rank = (query, context = {}) => view.rank(MEM, query, { limit: 3, requireApplicable: true, context });
+
+let passed = 0;
+const test = (name, fn) => {
+  fn();
+  passed += 1;
+  console.log(`eval: ${name}`);
+};
+
+test('该召回的 10 条都进前三', () => {
+  const missed = RECALL.filter(([query, want]) => !rank(query).slice(0, 3).some((row) => titleOf(row) === want));
+  const recallAt3 = (RECALL.length - missed.length) / RECALL.length;
+  assert.ok(recallAt3 >= 0.9, `Recall@3 ${recallAt3}；漏了：${missed.map((row) => row[0]).join('、')}`);
+});
+
+test('该拒绝的 10 条一条都不出现', () => {
+  const leaked = REJECT.filter((query) => rank(query).length > 0);
+  assert.equal(leaked.length, 0, `误触发：${leaked.join('、')}`);
+});
+
+test('条件未确认的 10 条不会当作已适用出现', () => {
+  const exposed = AWAIT.filter(([query, want]) => rank(query).some((row) => titleOf(row) === want));
+  assert.equal(exposed.length, 0, `条件未知却进了上下文：${exposed.map((row) => row[0]).join('、')}`);
+});
+
+test('条件确认之后同一条就能用', () => {
+  const rows = rank('这台机器部署前要确认什么？', { taskKind: 'deploy' });
+  assert.ok(rows.some((row) => titleOf(row) === '部署前确认目标机器'));
+});
+
+test('措辞不同也能召回（同义说法不依赖逐字重合）', () => {
+  assert.ok(rank('热刷新不生效是不是要重启').some((row) => titleOf(row) === '插件改完先试热刷新'));
+});
+
+console.log(`eval: ${passed} passed`);

package/test/evolution-read.test.mjs

@@ -63,7 +63,7 @@ const save = (scope, fields) => {
 };
 
 /** 直接种一条实验来源条目，绕开 PR4 的整理入口。 */
-function seedRule(scope, { title, body, summary, conditions = [], learning = { state: 'active' }, topicKey, tags = [] }) {
+function seedRule(scope, { title, body, summary, conditions = [], learning = { state: 'active', specDigest: 'seeded' }, topicKey, tags = [] }) {
   const saved = save(scope, { title, body, summary, tags });
   state.transact(scope, {}, (draft) => {
     const row = draft.entries.find((entry) => entry.id === saved.id);
@@ -169,7 +169,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
   const text = runtime.text(agent, sig);
   assert.match(text, /项目实验规则/);
   assert.match(text, /先给结论再解释/);
-  assert.ok(text.includes(id));
+  assert.ok(!text.includes(id), '实验规则也只给标题，不给内部编号');
   assert.doesNotMatch(text, /第 .* 版/);
 }
 
@@ -185,7 +185,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
   const sig = signal();
   await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期口播怎么做')));
   const text = runtime.text(agent, sig);
-  assert.ok(text.includes(id));
+  assert.ok(!text.includes(id), '实验规则也只给标题，不给内部编号');
   assert.match(text, /memory_read/);
   assert.equal(text.includes('先做这一步再检查'), false);
   assert.equal(Buffer.byteLength(text) <= 1200 + 200, true);
@@ -388,7 +388,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
     title: '暂停口播规则',
     body: '这条已经暂停，不该给正文。',
     conditions: [{ key: 'seriesId', value: '口播' }],
-    learning: { state: 'paused', blockedReason: 'needs_revalidation' },
+    learning: { state: 'paused', blockedReason: 'needs_revalidation', specDigest: 'seeded' },
   });
   enable(scope, { seriesId: '口播' });
   const runtime = boot();
@@ -424,7 +424,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
   await runtime.preStep({ agent, signal: signal(), turn: 't1' }, enter(human('这期口播开头')));
   const value = await runtime.exec('memory_search', { query: '口播开头', bindForRequest: true }, agent);
   assert.equal(value.status, 'ok');
-  assert.equal((value.refs || []).some((ref) => ref.id === id), true);
+  assert.equal((value.refs || []).some((ref) => ref.title === '口播开头'), true);
   const episodes = Object.values(store.taskState(scope).episodes);
   assert.equal(episodes.length, 1);
   assert.equal(episodes[0].status, 'proposed');
@@ -435,7 +435,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
   const dir = mkdir('fixed');
   const scope = scopeOf(dir);
   save(scope, { title: '固定发布检查', body: '发版前跑一遍检查。', tags: ['发布'] });
-  seedRule(scope, { title: '实验发布检查', body: '实验规则：发版前先备份。', tags: ['发布'], learning: { state: 'active' } });
+  seedRule(scope, { title: '实验发布检查', body: '实验规则：发版前先备份。', tags: ['发布'], learning: { state: 'active', specDigest: 'seeded' } });
   enable(scope);
   const runtime = boot();
   const agent = makeAgent('a-fixed', dir);
@@ -473,7 +473,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
     title: '过期口播规则',
     body: '这条试用已经到期，不该自动出现。',
     conditions: [{ key: 'seriesId', value: '口播' }],
-    learning: { state: 'trial', trialUntil: new Date(Date.now() - 60_000).toISOString() },
+    learning: { state: 'trial', specDigest: 'seeded', trialUntil: new Date(Date.now() - 60_000).toISOString() },
   });
   enable(scope, { seriesId: '口播' });
   const runtime = boot();
@@ -494,7 +494,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
     title: '快到期口播规则',
     body: '这条试用马上到期，过期后同一请求也不能再出现。',
     conditions: [{ key: 'seriesId', value: '口播' }],
-    learning: { state: 'trial', trialUntil: new Date(Date.now() + 700).toISOString() },
+    learning: { state: 'trial', specDigest: 'seeded', trialUntil: new Date(Date.now() + 700).toISOString() },
   });
   enable(scope, { seriesId: '口播' });
   const runtime = boot();
@@ -514,14 +514,14 @@ const scopeOf = (dir) => store.scopeOf(dir);
     title: '快到期的主题规则',
     body: '这条试用马上到期。',
     conditions: [{ key: 'seriesId', value: '口播' }],
-    learning: { state: 'trial', trialUntil: new Date(Date.now() + 700).toISOString() },
+    learning: { state: 'trial', specDigest: 'seeded', trialUntil: new Date(Date.now() + 700).toISOString() },
     topicKey: 'theme',
   });
   seedRule(scope, {
     title: '长期口播开头',
     body: '开场三句内给结论。',
     conditions: [{ key: 'seriesId', value: '口播' }],
-    learning: { state: 'active' },
+    learning: { state: 'active', specDigest: 'seeded' },
     topicKey: 'opening',
   });
   enable(scope, { seriesId: '口播' });
@@ -575,4 +575,27 @@ const scopeOf = (dir) => store.scopeOf(dir);
   assert.match(value.text, /适用条件还没确认/);
 }
 
+/* L22：自动续写轮没有新的真人消息，仍沿用本会话上一次的请求上下文读正文。 */
+{
+  const dir = mkdir('continuation');
+  const scope = scopeOf(dir);
+  const saved = save(scope, { title: '口播发布清单', body: '按清单逐项确认。' });
+  state.transact(scope, {}, (draft) => {
+    const row = draft.entries.find((entry) => entry.id === saved.id);
+    row.current.conditions = [{ key: 'seriesId', value: '口播' }];
+    return { changed: true };
+  });
+  enable(scope, { seriesId: '口播' });
+  const runtime = boot();
+  const agent = makeAgent('a-continuation', dir);
+  await runtime.preStep({ agent, signal: signal(), turn: 't1' }, enter(human('这期口播怎么做')));
+  const first = await runtime.exec('memory_read', { id: saved.id }, agent);
+  await runtime.preStep({ agent, signal: signal(), turn: 't2' }, enter());
+  assert.equal(first.status, 'ok');
+  assert.match(first.body, /按清单逐项确认/);
+  const second = await runtime.exec('memory_read', { id: saved.id }, agent);
+  assert.equal(second.status, 'ok');
+  assert.equal(second.repeat, true);
+}
+
 console.log('evolution-read.test.mjs: all passed');

package/test/ha.test.mjs

@@ -0,0 +1,186 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+process.env.DSH_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-ha-'));
+const store = await import('../store.js');
+const state = await import('../state.js');
+
+let passed = 0;
+const test = (name, fn) => {
+  try {
+    fn();
+    passed += 1;
+  } catch (error) {
+    console.error(`FAIL ${name}`);
+    throw error;
+  }
+};
+
+const dirs = [];
+const fresh = (label) => {
+  const dir = path.join(os.tmpdir(), `lite-memory-ha-${label}-${Math.random().toString(16).slice(2, 8)}`);
+  fs.mkdirSync(dir, { recursive: true });
+  dirs.push(dir);
+  return store.scopeOf(dir);
+};
+
+const lockOf = (scope) => path.join(scope.dir, '.lock');
+const currentOf = (scope) => path.join(scope.dir, 'state.json');
+const prevOf = (scope) => path.join(scope.dir, 'state.prev.json');
+
+test('P1-C: a lock left by a dead pid is reclaimed instead of reported busy', () => {
+  const scope = fresh('stale-lock');
+  fs.mkdirSync(scope.dir, { recursive: true });
+  fs.writeFileSync(lockOf(scope), '999999:deadbeef');
+  const saved = store.upsert(scope, { title: '锁回收', summary: '崩溃进程留下的锁不该卡住写入', body: '正文' });
+  assert.ok(saved.record.id.startsWith('mem_'));
+  assert.equal(fs.existsSync(lockOf(scope)), false);
+});
+
+test('P1-C: a lock held by a live pid still reports busy and is never deleted', () => {
+  const scope = fresh('live-lock');
+  fs.mkdirSync(scope.dir, { recursive: true });
+  const file = lockOf(scope);
+  fs.writeFileSync(file, `${process.pid}:live`);
+  try {
+    assert.throws(
+      () => store.upsert(scope, { title: '忙', summary: '另一个进程正在写', body: '正文' }),
+      (error) => error.code === 'busy' && /另一个进程/.test(error.message),
+    );
+    assert.equal(fs.readFileSync(file, 'utf8'), `${process.pid}:live`);
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('P0-B: 别的项目占着全局锁，本项目保存自己的条目照样能写', () => {
+  const project = fresh('other-project-save');
+  const global = store.globalScope();
+  fs.mkdirSync(global.dir, { recursive: true });
+  const file = lockOf(global);
+  fs.writeFileSync(file, `${process.pid}:busy-global`);
+  try {
+    const saved = store.saveEntry(project, {
+      title: '本项目照常保存',
+      summary: '别的项目或全局在写，不影响本项目的记忆',
+      body: '本项目照常保存正文。',
+      memoryClass: 'project_fact',
+    });
+    assert.equal(saved.chosenScope, 'project');
+    assert.ok(saved.record && saved.record.id.startsWith('mem_'));
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('P0-B: a corrupt state.json falls back to state.prev.json and says so', () => {
+  const scope = fresh('recover');
+  store.upsert(scope, { title: '第一条', summary: '先写一条', body: '正文一' });
+  store.upsert(scope, { title: '第二条', summary: '再写一条，prev 才有货', body: '正文二' });
+  assert.ok(fs.existsSync(prevOf(scope)), 'second publish should have produced state.prev.json');
+  fs.writeFileSync(currentOf(scope), '{"format":"broken"');
+  const loaded = state.load(scope);
+  assert.equal(loaded.recovered, true);
+  assert.ok(loaded.state.entries.length >= 1);
+  assert.match(loaded.recovery.message, /已从上一版恢复/);
+});
+
+test('P0-B: recovery does not bring a closed memory switch back on its own', () => {
+  const scope = fresh('recover-auth');
+  store.upsert(scope, { title: '关闭前的一条', summary: '先有数据', body: '正文' });
+  store.setMemoryEnabled(scope, false, { operationId: 'op-close' });
+  // 关闭这一版是 current；prev 还是开启状态。current 坏掉后恢复的是 prev。
+  assert.equal(store.controlStatus(scope).enabled, false);
+  fs.writeFileSync(currentOf(scope), '{"format":"broken"');
+  const loaded = state.load(scope);
+  assert.equal(loaded.recovered, true);
+  assert.equal(loaded.state.control.recoveryPending, true);
+  assert.equal(store.controlStatus(scope).enabled, false, '恢复出来仍是关闭，不能自己恢复授权');
+  const reopened = store.setMemoryEnabled(scope, true, { operationId: 'op-reopen' });
+  assert.equal(reopened.ok, true);
+  assert.equal(store.controlStatus(scope).enabled, true);
+  assert.equal(store.controlStatus(scope).recoveryPending, false, '用户明确开启后不再待确认');
+});
+
+test('P0-B: both files unreadable gives a recovery step, not just a path', () => {
+  const scope = fresh('both-bad');
+  store.upsert(scope, { title: '第一条', summary: '先写一条', body: '正文一' });
+  store.upsert(scope, { title: '第二条', summary: '再写一条', body: '正文二' });
+  fs.writeFileSync(currentOf(scope), 'broken');
+  fs.writeFileSync(prevOf(scope), 'broken too');
+  try {
+    state.load(scope);
+    assert.fail('expected a corrupt error');
+  } catch (error) {
+    assert.equal(error.code, 'corrupt');
+    assert.match(error.message, /恢复/);
+    assert.match(error.message, /state\.prev\.json/);
+  }
+});
+
+test('P0-A: writeDurable publishes atomically and leaves no temp file behind', () => {
+  const dir = path.join(os.tmpdir(), `lite-memory-durable-${Math.random().toString(16).slice(2, 8)}`);
+  fs.mkdirSync(dir, { recursive: true });
+  dirs.push(dir);
+  const file = path.join(dir, 'x.json');
+  state.writeDurable(file, '{"ok":true}');
+  assert.equal(fs.readFileSync(file, 'utf8'), '{"ok":true}');
+  assert.deepEqual(fs.readdirSync(dir), ['x.json']);
+  state.writeDurable(file, 'second');
+  assert.equal(fs.readFileSync(file, 'utf8'), 'second');
+});
+
+test('P0-A: a failing write surfaces as unavailable and does not clobber the good file', () => {
+  const dir = path.join(os.tmpdir(), `lite-memory-durable-bad-${Math.random().toString(16).slice(2, 8)}`);
+  fs.mkdirSync(dir, { recursive: true });
+  dirs.push(dir);
+  const file = path.join(dir, 'x.json');
+  state.writeDurable(file, 'good');
+  const frozen = path.join(dir, 'frozen');
+  fs.mkdirSync(frozen);
+  if (process.platform === 'win32') {
+    // Windows has no directory write bit: chmod on a folder changes nothing, so
+    // the injection has to be a failure Windows actually raises. A directory in
+    // the way of the final rename is EPERM here and EISDIR on POSIX — both must
+    // surface as `unavailable`, and neither may touch the good file beside it.
+    const blocked = path.join(dir, 'blocked.json');
+    fs.mkdirSync(blocked);
+    assert.throws(
+      () => state.writeDurable(blocked, 'nope'),
+      (error) => error.code === 'unavailable' && /写不进去/.test(error.message),
+    );
+  } else {
+    fs.chmodSync(frozen, 0o500);
+    try {
+      assert.throws(
+        () => state.writeDurable(path.join(frozen, 'y.json'), 'nope'),
+        (error) => error.code === 'unavailable' && /写不进去/.test(error.message),
+      );
+    } finally {
+      fs.chmodSync(frozen, 0o700);
+    }
+  }
+  assert.equal(fs.readFileSync(file, 'utf8'), 'good');
+});
+
+test('P1-D: archived body round-trips through cold storage, and corrupt cold fails loudly', () => {
+  const scope = fresh('cold');
+  const saved = store.upsert(scope, { title: '冷存', summary: '归档正文放冷存', body: '归档正文内容' });
+  const archived = store.forget(scope, saved.record.id, { mode: 'archive' });
+  assert.ok(['archive', 'archived'].includes(archived.mode));
+  const cold = path.join(scope.dir, 'cold', `${saved.record.id}.json`);
+  assert.ok(fs.existsSync(cold), 'cold file should exist for an archived record');
+  assert.equal(JSON.parse(fs.readFileSync(cold, 'utf8')).body, '归档正文内容');
+  assert.equal(store.readEntry(scope, saved.record.id).body, '归档正文内容');
+  fs.writeFileSync(cold, '{broken');
+  assert.throws(
+    () => store.readEntry(scope, saved.record.id),
+    (error) => error.code === 'cold_corrupt' && /冷存/.test(error.message),
+    'a broken cold file must never read back as an empty body',
+  );
+});
+
+for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true });
+console.log(`test/ha.test.mjs: ${passed} passed`);