dsh-lite-memory 0.17.0 → 0.18.19

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');

package/test/learning.test.mjs

@@ -962,6 +962,86 @@ test('L03b 明确长期要求整理为空时也留下规则', () => {
   assert.equal(learning.pendingChangeFrom({ text: '   ' }), null);
 });
 
+test('L03c 兜底不把没说范围的要求抬成全项目规则', () => {
+  const vague = learning.pendingChangeFrom({ text: '以后口播开头先给结论。', cue: { explicitLongTerm: true } });
+  assert.equal(vague.applicability, 'unresolved');
+  const allLines = learning.pendingChangeFrom({ text: '以后所有口播都先给结论。', cue: { explicitLongTerm: true } });
+  assert.equal(allLines.applicability, 'all_in_scope', '「所有口播」按项目层全范围收集');
+  const always = learning.pendingChangeFrom({ text: '以后一律先给结论。', cue: { explicitLongTerm: true } });
+  assert.equal(always.applicability, 'all_in_scope', '「一律」按项目层全范围收集');
+  assert.deepEqual(vague.conditions, []);
+  const scoped = learning.pendingChangeFrom({ text: '以后口播开头先给结论。', cue: { explicitLongTerm: true, taskKind: 'video' } });
+  assert.equal(scoped.applicability, 'conditional');
+  assert.deepEqual(scoped.conditions, [{ key: 'taskKind', value: 'video' }]);
+  const global = learning.pendingChangeFrom({ text: '以后这个项目默认用 pnpm。', cue: { explicitLongTerm: true } });
+  assert.equal(global.applicability, 'all_in_scope');
+  assert.deepEqual(global.conditions, []);
+});
+
+test('L03d 作用域在收集时固定，整理只能沿用或收窄', () => {
+  const human = (id, text) => ({ id, source: { kind: 'user' }, content: [{ type: 'text', text }] });
+  const anchor = { episodeId: 'ep_x', status: 'unbound', updatedAt: '2026-01-01T00:00:00.000Z' };
+  const narrow = learning.candidateFrom({ messages: [human('m1', '以后开头先给结论')], anchor, projectId: 'p' });
+  assert.equal(narrow.expectedTarget.applicability, 'unresolved');
+  const wide = learning.candidateFrom({ messages: [human('m2', '以后这个项目默认用 pnpm')], anchor, projectId: 'p' });
+  assert.equal(wide.expectedTarget.applicability, 'all_in_scope');
+
+  const refs = { feedback: { u0: 'm1' }, rules: {} };
+  const base = { target: 'new', feedbackType: 'spec_change', topicKey: '开头', currentText: '开头先给结论', evidence: ['u0'] };
+  const needsScope = learning.validateChange({ ...base, applicability: 'all_in_scope' }, { refs, rules: [], ranges: RANGES, expectedTarget: narrow.expectedTarget });
+  assert.equal(needsScope.ok, false);
+  assert.match(needsScope.reason, /不能.*全项目/);
+  assert.equal(learning.validateChange({ ...base, applicability: 'unresolved' }, { refs, rules: [], ranges: RANGES, expectedTarget: narrow.expectedTarget }).ok, true);
+  assert.equal(learning.validateChange({ ...base, applicability: 'all_in_scope' }, { refs, rules: [], ranges: RANGES, expectedTarget: wide.expectedTarget }).ok, true);
+
+  const video = { scope: 'episode', episodeId: 'ep_x', taskKind: 'video' };
+  const episodeWide = learning.validateChange({ ...base, applicability: 'all_in_scope' }, { refs, rules: [], ranges: RANGES, expectedTarget: video });
+  assert.equal(episodeWide.ok, false, '作品规则不能抬成全项目');
+  const droppedKind = learning.validateChange({ ...base, applicability: 'conditional', conditions: [{ key: 'phase', value: 'script' }] }, { refs, rules: [], ranges: RANGES, expectedTarget: video });
+  assert.equal(droppedKind.ok, false, '不能删掉收集时的任务范围');
+  const keptKind = learning.validateChange({ ...base, applicability: 'conditional', conditions: [{ key: 'taskKind', value: 'video' }, { key: 'phase', value: 'script' }] }, { refs, rules: [], ranges: RANGES, expectedTarget: video });
+  assert.equal(keptKind.ok, true, keptKind.reason);
+
+  const fallback = learning.pendingChangeFrom({ text: '以后所有开头都先给结论。', cue: { explicitLongTerm: true }, expectedTarget: narrow.expectedTarget });
+  assert.equal(fallback.applicability, 'unresolved', '兜底不重新推导作用域');
+  assert.equal(learning.pendingChangeFrom({ text: '以后开头都先给结论。', cue: { explicitLongTerm: true }, expectedTarget: wide.expectedTarget }).applicability, 'all_in_scope');
+});
+
+test('L03e 先按相关性排序再截断，输入顺序不挤掉真正相关的旧规则', () => {
+  const rules = [];
+  for (let index = 0; index < 32; index += 1) {
+    rules.push({
+      id: `mem_${String(index).padStart(2, '0')}`,
+      state: 'active',
+      updated: `2026-01-${String((index % 28) + 1).padStart(2, '0')}T00:00:00.000Z`,
+      title: index === 31 ? '字幕字号' : `无关规则${index}`,
+      summary: '',
+      body: index === 31 ? '字幕固定 32 号' : '',
+      conditions: [],
+    });
+  }
+  const selected = learning.selectRules(rules, { query: '字幕太小了，改大一点', dimensions: ['字幕'], limit: 6 });
+  assert.equal(selected.length, 6);
+  assert.ok(selected.some((row) => row.id === 'mem_31'), '相关但排在最后的规则要进候选');
+  assert.equal(learning.selectRules(rules, { limit: 32 }).length, 32, '候选池上限是 32 条，不是先砍到 6 条');
+});
+
+test('L03f 整理器规则先按状态和最近使用排序再取 8 条', () => {
+  const rules = [];
+  for (let index = 0; index < 12; index += 1) {
+    rules.push({
+      id: `mem_${String(index).padStart(2, '0')}`,
+      state: index === 11 ? 'active' : index === 10 ? 'trial' : 'paused',
+      updatedAt: `2026-01-${String(index + 1).padStart(2, '0')}T00:00:00.000Z`,
+      title: `规则${index}`,
+    });
+  }
+  const ordered = learning.orderOrganizerRules(rules);
+  assert.equal(ordered.length, learning.LIMITS.organizerRules);
+  assert.equal(ordered[0].id, 'mem_11', '生效规则优先于暂停规则');
+  assert.equal(ordered[1].id, 'mem_10', '试用规则排在暂停之前');
+});
+
 test('L04 先算目标状态再查配额，过期候选可恢复', () => {
   const base = { existing: null, evidence: { episodeId: 'e1', messageIds: ['m1'], sourceExcerpt: '以后都用参数化查询' }, pending: 12, rules: 0, now: 1000 };
   const active = learning.admitChange({ ...base, change: NEW_CHANGE, explicitLongTerm: true });

package/test/palace.test.mjs

@@ -90,8 +90,10 @@ const walk = (node, out = [], expand = false) => {
 };
 const exhibit = walk(tree, [], true).find((node) => node.type === 'button' && node.props.title === 'A');
 assert.ok(exhibit, '展品应是原生按钮');
+const beforeClick = JSON.stringify(tree);
 exhibit.props.onClick();
 assert.equal(picked, 'mem_a');
+assert.equal(JSON.stringify(tree), beforeClick, '点开展品只换详情，不改宫殿里的记录');
 
 // 首帧列表视图不挂载宫殿；空数据时给下一步提示。
 const firstPaint = MemoryPanel({ sessionId: 'demo', onClose: () => {} });

package/test/recall.test.mjs

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
+import crypto from 'node:crypto';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -8,8 +9,9 @@ const { apply } = await import('../index.js');
 const store = await import('../store.js');
 
 const HEADER = '已有记忆可能相关';
-const CARD_LINE = /^- \[[^\]]+\] 「.+?」.* · mem_[a-z0-9]+(?:｜.*)?$/;
+const CARD_LINE = /^- \[[^\]]+\] 「.+?」(?:｜.*)?$/;
 const CARD_LINE_M = new RegExp(CARD_LINE.source, 'm');
+const INTERNAL_ID = /mem_[a-z0-9]{6,}/;
 
 const effect = (fn) => {
   const dispose = fn();
@@ -84,6 +86,17 @@ const save = (scope, fields) => {
   return { ...result, id: result.record?.id ?? result.id };
 };
 
+/** 有效期这类时间不能靠等待制造：直接改热状态，并同步重算校验和。 */
+const patchState = (scope, id, patch) => {
+  const file = path.join(scope.dir, 'state.json');
+  const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+  const entry = raw.payload.entries.find((row) => row.id === id);
+  assert.ok(entry, `state 里没有 ${id}`);
+  Object.assign(entry, patch);
+  raw.checksum = `sha256:${crypto.createHash('sha256').update(JSON.stringify(raw.payload)).digest('hex')}`;
+  fs.writeFileSync(file, `${JSON.stringify(raw, null, 2)}\n`);
+};
+
 const cwdA = mkdir('a');
 const scopeA = store.scopeOf(cwdA);
 const global = store.globalScope();
@@ -277,8 +290,7 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   const fourth = await bootA.exec('memory_read', { id: bigBodies[3].id }, agent);
   assert.equal(fourth.status, 'budget_exhausted');
   assert.equal(fourth.body || '', '');
-  assert.equal(fourth.id, '');
-  assert.equal(bootA.render('memory_read', {}, fourth), 'memory · 本请求的记忆额度已用完');
+  assert.equal(bootA.render('memory_read', {}, fourth), 'memory · 这条消息已停止读记忆，下一条消息再读');
   const win = bootA.debug.windowOf(agent);
   assert.ok(win.bytes <= 8192);
   assert.equal(win.bodies, 3);
@@ -332,10 +344,11 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   const agent = makeAgent('agent-purge', cwdD);
   const sig = signal();
   await bootA.preStep({ agent, signal: sig, turn: 't1' }, enter(human('插件改完怎么让它生效？')));
-  assert.match(bootA.provider.text({ agent, signal: sig }), new RegExp(doomed.id));
-  const purged = await bootA.exec('memory_forget', { id: doomed.id, mode: 'purge' }, agent);
+  assert.match(bootA.provider.text({ agent, signal: sig }), /插件改完要重启应用/);
+  const purged = await bootA.exec('memory_forget', { title: '插件改完要重启应用', mode: 'purge' }, agent);
   assert.equal(purged.mode, 'purged');
-  assert.match(bootA.provider.text({ agent, signal: sig }), new RegExp(doomed.id), '已提交的旧快照不回头改写');
+  assert.match(bootA.provider.text({ agent, signal: sig }), /插件改完要重启应用/, '已提交的旧快照不回头改写');
+  assert.doesNotMatch(bootA.provider.text({ agent, signal: sig }), /mem_[a-z0-9]{6,}/, '召回卡从不带内部编号');
   const sig2 = signal();
   await bootA.preStep({ agent, signal: sig2, turn: 't2' }, enter(human('插件改完怎么让它生效？')));
   const after = bootA.provider.text({ agent, signal: sig2 });
@@ -359,7 +372,7 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   const agent = makeAgent('agent-global-purge', cwdA);
   const sig = signal();
   await bootA.preStep({ agent, signal: sig, turn: 't1' }, enter(human('发布前跑文案检查')));
-  assert.match(bootA.provider.text({ agent, signal: sig }), new RegExp(globalNote.id));
+  assert.match(bootA.provider.text({ agent, signal: sig }), /全局发布前文案核对/);
   const purged = store.forget(global, globalNote.id, { mode: 'purge' });
   assert.equal(purged.mode, 'purged');
   /** 同一 turn 的续步没有新真人消息：不重新问人，但盘上变了必须换掉快照。 */
@@ -387,12 +400,25 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
     if (row.status === 'budget_exhausted') exhausted = row;
   }
   assert.ok(exhausted, '超过额度后拒绝读正文');
-  assert.equal(exhausted.id, '');
+  assert.equal(exhausted.id, undefined);
   assert.ok(win.bytes <= 8192);
   assert.ok(win.bodies <= 3);
   assert.ok(win.reads <= 8);
 }
 
+// A21：自动注入把这一轮用得差不多，模型按标题来读正文不该被连带挡掉。
+{
+  const agent = makeAgent('agent-read-after-auto', cwdA);
+  await prepare(bootA, agent, '大正文样本怎么用');
+  const win = bootA.debug.windowOf(agent);
+  assert.ok(win, '自动召回开了额度窗口');
+  /** 模拟自动注入已经把这轮的 8192 B 用满。 */
+  win.bytes = 8192;
+  const row = await bootA.exec('memory_read', { title: '大正文样本1' }, agent);
+  assert.equal(row.status, 'ok', '自动注入用满之后仍能读正文');
+  assert.ok(Buffer.byteLength(row.body) > 900);
+}
+
 // A18：归档/旧正文不进正常检索；只有明确查历史才列归档。
 {
   const cwdE = mkdir('e');
@@ -410,7 +436,7 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   const oldBody = save(scopeE, { title: '口端口令', tags: ['端口'], summary: '端口以最新为准', body: '第一版：端口是 5000' });
   store.upsert(scopeE, { id: oldBody.id, title: '口端口令', summary: '端口以最新为准', body: '第二版：端口是 49661' });
   const current = await bootA.exec('memory_search', { query: '口端口令', history: true }, agent);
-  assert.ok(current.refs.some((ref) => ref.id === oldBody.id && ref.revision === 2), '检索只给当前版本');
+  assert.ok(current.refs.some((ref) => ref.title === '口端口令' && ref.revision === 2), '检索只给当前版本');
   const latest = await bootA.exec('memory_read', { id: oldBody.id }, agent);
   assert.match(latest.body, /第二版/);
   assert.doesNotMatch(latest.body, /第一版/);
@@ -436,6 +462,38 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   assert.ok(win.bytes <= 8192);
 }
 
+// 生命周期退出默认召回：被取代、过期的条目不再自动注入，也不再进手动检索。
+{
+  const runtime = boot();
+  const cwdLife = mkdir('lifecycle');
+  const scopeLife = store.scopeOf(cwdLife);
+  const oldDeploy = save(scopeLife, {
+    title: '旧部署目标', summary: '部署到 staging，旧流程。', body: '旧流程只发 staging。', resolution: 'distinct',
+  });
+  const newDeploy = save(scopeLife, {
+    title: '新部署目标', summary: '部署到 production，先跑测试。', body: '新流程先跑测试再发 production。', resolution: 'distinct',
+    supersedes: oldDeploy.id,
+  });
+  const stalePort = save(scopeLife, {
+    title: '临时调试端口', summary: '本地服务跑在 18080。', body: '旧端口已经不用了。', resolution: 'distinct',
+  });
+  patchState(scopeLife, stalePort.id, {
+    validFrom: new Date(Date.now() - 7200_000).toISOString(),
+    validUntil: new Date(Date.now() - 3600_000).toISOString(),
+  });
+  const agentLife = makeAgent('agent-lifecycle', cwdLife);
+  const lifeSignal = await prepare(runtime, agentLife, '部署目标怎么走，临时调试端口是多少');
+  const text = runtime.provider.text({ agent: agentLife, signal: lifeSignal });
+  assert.match(text, /新部署目标/);
+  assert.doesNotMatch(text, /旧部署目标|旧流程只发 staging/, '被取代的条目退出自动召回');
+  assert.doesNotMatch(text, /临时调试端口|旧端口已经不用了/, '过期的条目退出自动召回');
+  const found = await runtime.exec('memory_search', { query: '部署目标' }, agentLife);
+  assert.equal(found.refs.some((ref) => ref.title === '旧部署目标'), false);
+  assert.equal(found.refs.some((ref) => ref.title === '新部署目标'), true);
+  const port = await runtime.exec('memory_search', { query: '临时调试端口' }, agentLife);
+  assert.equal(port.refs.some((ref) => ref.title === '临时调试端口'), false, '过期条目也不进默认检索');
+}
+
 // A20：没有命中是正常空结果，不是额度用尽。
 {
   const agent = makeAgent('agent-empty-search', cwdA);
@@ -461,3 +519,16 @@ console.log('recall.test.mjs: ok');
   assert.equal(links.status, 'needs_context');
   assert.doesNotMatch(JSON.stringify(links), /发布前要检查什么/);
 }
+
+// A24：纯英文查询按整词判断，自动注入和手动搜索必须给同一个结论。
+{
+  const cwdEn = mkdir('en');
+  const scopeEn = store.scopeOf(cwdEn);
+  save(scopeEn, { title: 'Digital asset catalog', summary: '图形素材目录' });
+  const agent = makeAgent('agent-en', cwdEn);
+  const runtime = boot();
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('git')));
+  assert.doesNotMatch(runtime.provider.text({ agent, signal: sig }), /Digital asset catalog/);
+  assert.equal(store.search(scopeEn, 'git', 5).length, 0, '手动搜索也不给这条');
+}