dsh-lite-memory 0.18.1 → 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/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: '口播' });

package/test/ha.test.mjs

@@ -55,6 +55,26 @@ test('P1-C: a lock held by a live pid still reports busy and is never deleted',
   }
 });
 
+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: '正文一' });
@@ -67,6 +87,23 @@ test('P0-B: a corrupt state.json falls back to state.prev.json and says so', ()
   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: '正文一' });
@@ -103,14 +140,27 @@ test('P0-A: a failing write surfaces as unavailable and does not clobber the goo
   state.writeDurable(file, 'good');
   const frozen = path.join(dir, 'frozen');
   fs.mkdirSync(frozen);
-  fs.chmodSync(frozen, 0o500);
-  try {
+  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(path.join(frozen, 'y.json'), 'nope'),
+      () => state.writeDurable(blocked, 'nope'),
       (error) => error.code === 'unavailable' && /写不进去/.test(error.message),
     );
-  } finally {
-    fs.chmodSync(frozen, 0o700);
+  } 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');
 });

package/test/layer-read.test.mjs

@@ -0,0 +1,293 @@
+import { fileURLToPath } from 'node:url'
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+
+process.env.DSH_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-layer-'));
+const { apply } = await import('../index.js');
+const store = await import('../store.js');
+
+const effect = (fn) => {
+  const dispose = fn();
+  return typeof dispose === 'function' ? dispose : () => {};
+};
+const defs = new Map();
+const ctx = {
+  tools: { register: (def) => { defs.set(def.name, def); return () => {}; } },
+  effect,
+  inject: () => () => {},
+  get: () => undefined,
+  on: () => () => {},
+};
+apply(ctx, { mode: 'adaptive' });
+const exec = (name, args, cwd) => defs.get(name).execute(args, { agent: { cwd } });
+const render = (name, args, value) => defs.get(name).output.render(args, value)[0].text;
+
+const dirOf = (label) => {
+  const dir = path.join(os.tmpdir(), `lite-memory-layer-${label}-${Math.random().toString(16).slice(2, 8)}`);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+};
+const projectA = dirOf('a');
+const projectB = dirOf('b');
+
+// A 项目存一条普通记忆；B 的运行时不得通过标题或 id 拿到 A 的正文。
+const saved = store.saveEntry(store.scopeOf(projectA), {
+  title: '甲项目发布约定',
+  summary: '甲项目部署前先维护独立业务队列',
+  body: '甲项目专用：部署前先维护独立业务队列。',
+  memoryClass: 'project_fact',
+});
+assert.equal(saved.chosenScope, 'project');
+const idOfA = saved.record.id;
+
+const layers = store.runtimeLayers(store.scopeOf(projectB)).map((item) => item.key);
+assert.equal(layers.length, 2, '运行时只有当前项目和全局两层');
+assert.ok(!layers.includes(store.scopeOf(projectA).key), '运行时层不枚举其他项目');
+
+await assert.rejects(
+  () => exec('memory_read', { title: '甲项目发布约定' }, projectB),
+  /没有「甲项目发布约定」这条记忆/,
+  '跨项目标题不得解析到别的项目',
+);
+await assert.rejects(
+  () => exec('memory_read', { id: idOfA }, projectB),
+  /没有「.*」这条记忆/,
+  '跨项目 id 也不得读到正文',
+);
+assert.equal(store.locate(store.scopeOf(projectB), idOfA), null, '默认 locate 不跨层');
+
+// B 读自己的条目：运行时只锁当前项目和全局，A 的条目不在枚举里。
+const own = store.saveEntry(store.scopeOf(projectB), {
+  title: '乙项目发布约定',
+  summary: '乙项目部署前先跑迁移',
+  body: '乙项目专用：部署前先跑迁移。',
+  memoryClass: 'project_fact',
+});
+assert.ok(own.record);
+const readOwn = await exec('memory_read', { title: '乙项目发布约定' }, projectB);
+assert.equal(readOwn.status, 'ok');
+assert.match(readOwn.body, /先跑迁移/);
+assert.equal(readOwn.scope, 'project');
+
+// 同名项目／全局条目：指定 global 只解析全局，不串到项目层。
+store.saveEntry(store.globalScope(), {
+  title: '同名发布约定',
+  summary: '全局：发布前先确认远端已推送',
+  body: '全局：发布前先确认远端已推送。',
+  memoryClass: 'personal_preference',
+});
+store.saveEntry(store.scopeOf(projectB), {
+  title: '同名发布约定',
+  summary: '项目：发布前先更新 CHANGELOG',
+  body: '项目：发布前先更新 CHANGELOG。',
+  memoryClass: 'project_fact',
+  resolution: 'distinct',
+});
+const readGlobal = await exec('memory_read', { title: '同名发布约定', scope: 'global' }, projectB);
+assert.equal(readGlobal.status, 'ok');
+assert.match(readGlobal.body, /远端已推送/, 'scope:global 必须读全局那条');
+assert.match(render('memory_read', { title: '同名发布约定', scope: 'global' }, readGlobal), /^memory · \[global\] 「同名发布约定」/, '读到的全局条目要带 [global]，不能冒充当前项目');
+const readProject = await exec('memory_read', { title: '同名发布约定' }, projectB);
+assert.match(readProject.body, /CHANGELOG/, '不指定范围时先读当前项目');
+assert.doesNotMatch(render('memory_read', { title: '同名发布约定' }, readProject), /\[global\]/, '项目条目不能被标成全局');
+
+// 同名条目跨层更新：不指定范围先报候选，指定 global 只改全局，项目条目原样。
+const ambiguous = await exec('memory_save', {
+  updateTitle: '同名发布约定',
+  summary: '改了但没说是哪一层',
+  body: '改了但没说是哪一层。',
+  memoryClass: 'project_fact',
+}, projectB);
+assert.match(ambiguous.error, /各有一条/, '同名跨层不给默认匹配');
+const globalUpdate = await exec('memory_save', {
+  scope: 'global',
+  updateTitle: '同名发布约定',
+  summary: '全局：发布前先确认远端已推送并打 tag',
+  body: '全局：发布前先确认远端已推送并打 tag。',
+  memoryClass: 'personal_preference',
+}, projectB);
+assert.equal(globalUpdate.error, undefined);
+assert.equal(globalUpdate.scope, 'global');
+assert.match((await exec('memory_read', { title: '同名发布约定', scope: 'global' }, projectB)).body, /打 tag/);
+assert.match((await exec('memory_read', { title: '同名发布约定' }, projectB)).body, /CHANGELOG/, '项目条目没有被全局更新带跑');
+
+// 条件未确认：标题只能定位，不能证明适用；不返回正文。
+store.saveEntry(store.scopeOf(projectB), {
+  title: '发版当天步骤',
+  summary: '发版当天冻结、打标签、公告',
+  body: '冻结代码，然后打标签。',
+  when: '发版当天',
+  memoryClass: 'project_fact',
+});
+const conditional = await exec('memory_read', { title: '发版当天步骤' }, projectB);
+assert.equal(conditional.status, 'needs_context');
+assert.equal(conditional.body, '', '条件未知时标题读取不得先给正文');
+assert.equal(conditional.when, undefined);
+const text = defs.get('memory_read').output.render({}, conditional)[0].text;
+assert.doesNotMatch(text, /冻结代码/, '渲染文本也不得带正文');
+assert.doesNotMatch(text, /mem_[a-z0-9]{6,}/);
+
+// 只给 id 的程序化取用不放正文，门槛不变。
+await assert.rejects(
+  () => exec('memory_read', { id: 'mem_000000000000' }, projectB),
+  /没有「mem_000000000000」这条记忆/,
+);
+
+// 归档后仍能按标题彻底删除；归档不重新参与召回。
+const ownRecord = store.locateByTitle(store.scopeOf(projectB), '乙项目发布约定');
+assert.ok(ownRecord);
+store.forget(store.scopeOf(projectB), ownRecord.record.id, { mode: 'archive' });
+await exec('memory_forget', { title: '乙项目发布约定', mode: 'purge' }, projectB);
+assert.equal(store.locateByTitle(store.scopeOf(projectB), '乙项目发布约定'), null, '归档后可按标题 purge');
+assert.equal(store.locateByTitle(store.scopeOf(projectB), '乙项目发布约定', { crossLayer: true }), null, '彻底删除后哪一层都查不到');
+assert.equal(store.readEntry(store.scopeOf(projectB), ownRecord.record.id), null, '正文也不在了');
+
+// 显式 scope="project" 只解析项目层：全局唯一条目不能被读，更不能被 purge 掉。
+const globalOnly = store.saveEntry(store.globalScope(), {
+  title: '全局唯一凭据入口',
+  summary: '全局：凭据只从密码管理器取',
+  body: '全局：凭据只从密码管理器取，不写进仓库。',
+  memoryClass: 'personal_preference',
+});
+assert.ok(globalOnly.record, '全局条目已写入');
+await assert.rejects(
+  () => exec('memory_read', { title: '全局唯一凭据入口', scope: 'project' }, projectB),
+  /没有「全局唯一凭据入口」这条记忆/,
+  '显式项目层不得读到全局条目',
+);
+await assert.rejects(
+  () => exec('memory_forget', { title: '全局唯一凭据入口', scope: 'project', mode: 'purge' }, projectB),
+  /没有「全局唯一凭据入口」这条记忆/,
+  '显式项目层不得彻底删除全局条目',
+);
+const globalOnlyAfter = store.locate(store.scopeOf(projectB), globalOnly.record.id, { layers: [store.globalScope()] });
+assert.ok(globalOnlyAfter, '全局条目仍在原层');
+assert.match(globalOnlyAfter.record.body || '', /密码管理器/, '正文没有被错层删除');
+
+// 相近条目在另一层时，确认提示要给出能落地的动作：更新就落到那一层，否则会另建一条。
+const globalDraft = store.saveEntry(store.scopeOf(projectB), {
+  title: 'npm 发布凭据取用与发布后验版',
+  summary: 'npm 发布用 account regrevia，发布后轮询 dist-tags 验版',
+  body: '发布用 regrevia 身份；发完轮询 dist-tags.latest 判上线。',
+  memoryClass: 'personal_preference',
+});
+assert.equal(globalDraft.chosenScope, 'global');
+const near = await exec('memory_save', {
+  title: 'npm 发布凭据怎么取用、发完怎么验版',
+  summary: 'npm 发布用 regrevia，发完轮询 dist-tags 验证版本',
+  body: 'npm publish 之后轮询 dist-tags 确认版本。',
+  memoryClass: 'project_fact',
+}, projectB);
+assert.equal(near.needsResolution, true);
+assert.equal(near.crossLayer, true);
+assert.equal(near.crossScope, 'global');
+const nearText = defs.get('memory_save').output.render({}, near)[0].text;
+assert.match(nearText, /scope="global"/);
+assert.doesNotMatch(nearText, /mem_[a-z0-9]{6,}/);
+
+// 生命周期：被取代或过期的条目不再自动召回，也不通过标题读交正文。
+const view = await import('../view.js');
+const first = store.saveEntry(store.scopeOf(projectB), {
+  title: '旧版发布流程',
+  summary: '旧版：手工上传',
+  body: '旧版：手工上传到服务器。',
+  memoryClass: 'project_fact',
+});
+const next = store.saveEntry(store.scopeOf(projectB), {
+  title: '新版发布流程',
+  summary: '新版：CI 自动发布',
+  body: '新版：CI 自动发布。',
+  memoryClass: 'project_fact',
+  supersedes: first.record.id,
+  resolution: 'distinct',
+});
+assert.equal(next.chosenScope, 'project');
+const stale = view.eligibility({ ...first.record, validUntil: '', supersededBy: next.record.id }, {}, 'auto');
+assert.equal(stale.ok, false, '被取代的条目不得自动召回');
+assert.equal(stale.reason, 'superseded');
+const staleRead = await exec('memory_read', { title: '旧版发布流程' }, projectB);
+assert.equal(staleRead.status, 'gone', '被取代条目按标题读只报已不在');
+assert.equal(staleRead.body, '');
+const staleHits = store.search(store.scopeOf(projectB), '旧版发布流程');
+assert.ok(!staleHits.some((item) => (item.record || item).id === first.record.id || (item.record || item).title === '旧版发布流程'), '默认检索不返回被取代条目');
+assert.equal(view.eligibility({ status: 'active', validUntil: '2000-01-01T00:00:00Z' }, {}, 'auto').ok, false, '过期条目不得召回');
+assert.equal(view.eligibility({ status: 'active', validUntil: '2000-01-01T00:00:00Z' }, {}, 'read').reason, 'expired');
+
+// 忘掉同名条目：不带层就报候选，带 global 只归档全局，项目条目还在。
+await assert.rejects(() => exec('memory_forget', { title: '同名发布约定', mode: 'archive' }, projectB), /各有一条/, '同名跨层删除不给默认匹配');
+const globalForget = await exec('memory_forget', { title: '同名发布约定', scope: 'global', mode: 'archive' }, projectB);
+assert.equal(globalForget.mode, 'archive');
+assert.equal(globalForget.scope, 'global');
+assert.equal((await exec('memory_read', { title: '同名发布约定' }, projectB)).status, 'ok', '项目条目没被一起归档');
+const archivedGlobal = await exec('memory_read', { title: '同名发布约定', scope: 'global' }, projectB);
+assert.equal(archivedGlobal.status, 'archived', '归档条目按标题只报已归档');
+assert.equal(archivedGlobal.body, '');
+
+// 别的项目正在写，不影响本项目的读和写：运行时锁只覆盖当前项目和全局。
+store.saveEntry(store.scopeOf(projectB), {
+  title: '锁隔离验证',
+  summary: '锁隔离验证条目',
+  body: '锁隔离验证条目正文。',
+  memoryClass: 'project_fact',
+});
+const marker = path.join(os.tmpdir(), `lite-memory-hold-${Math.random().toString(16).slice(2, 8)}`);
+const repo = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
+const holder = spawn(process.execPath, ['--input-type=module', '-e', `
+  import fs from 'node:fs';
+  const { scopeOf } = await import('./store.js');
+  const state = await import('./state.js');
+  const scope = scopeOf(process.argv[1]);
+  state.withScopeLock(scope, () => {
+    fs.writeFileSync(process.argv[2], '1');
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 900);
+  });
+`, projectA, marker], { cwd: repo, stdio: 'ignore', env: process.env });
+for (let i = 0; i < 200 && !fs.existsSync(marker); i += 1) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+}
+assert.ok(fs.existsSync(marker), '子进程已拿到 A 项目锁');
+const started = Date.now();
+const lockedRead = await exec('memory_read', { title: '锁隔离验证' }, projectB);
+const elapsed = Date.now() - started;
+assert.equal(lockedRead.status, 'ok');
+assert.match(lockedRead.body, /锁隔离验证条目正文/);
+assert.ok(elapsed < 200, `A 项目持锁时 B 的读取不得等锁（实际 ${elapsed}ms）`);
+const lockedSave = await exec('memory_save', { title: '锁隔离验证二', summary: '第二条', body: '第二条正文。', memoryClass: 'project_fact' }, projectB);
+assert.equal(lockedSave.error, undefined);
+assert.equal(lockedSave.scope, 'project');
+holder.kill();
+
+// 关联清单也要标层：项目邻居与全局邻居一眼分得清，不靠标题猜。
+const globalLinkTarget = store.saveEntry(store.globalScope(), {
+  title: '全局关联目标',
+  summary: '全局层的邻居',
+  body: '全局层的邻居正文。',
+  memoryClass: 'personal_preference',
+});
+assert.ok(globalLinkTarget.record);
+const projectLinkTarget = store.saveEntry(store.scopeOf(projectB), {
+  title: '项目关联目标',
+  summary: '项目层的邻居',
+  body: '项目层的邻居正文。',
+  memoryClass: 'project_fact',
+  resolution: 'distinct',
+});
+assert.ok(projectLinkTarget.record);
+const linked = await exec('memory_save', {
+  title: '带两个邻居的条目',
+  summary: '同时关联项目与全局',
+  body: '同时关联项目与全局。',
+  memoryClass: 'project_fact',
+  links: [{ title: '项目关联目标' }, { title: '全局关联目标' }],
+}, projectB);
+assert.equal(linked.error, undefined);
+const linkView = await exec('memory_read', { title: '带两个邻居的条目', view: 'links' }, projectB);
+const linkText = render('memory_read', { title: '带两个邻居的条目', view: 'links' }, linkView);
+assert.match(linkText, /「项目关联目标」/);
+assert.match(linkText, /\[global\] 「全局关联目标」/, '全局邻居要带 [global]');
+assert.doesNotMatch(linkText, /\[global\] 「项目关联目标」/, '项目邻居不能被标成全局');
+
+console.log('layer-read ok');