dsh-lite-memory 0.18.1 → 0.18.19

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

package/test/state.test.mjs

@@ -84,6 +84,34 @@ test('2 版状态可读，下一次写入升级为 4 版并保留记录', () =>
   assert.equal(parsed.payload.entries[0].current.body, '升级后的正文');
 });
 
+test('D04b 旧实验规则缺作用域指纹时转待复核，正文与来源保留', () => {
+  const scope = fresh('legacy-rules');
+  transact(scope, { expectCreate: true }, (draft) => {
+    addNote('旧规则', '旧正文')(draft);
+    const entry = draft.entries[0];
+    entry.origin = 'project_evolution';
+    entry.maintenance.sourceRefs = [{ sourceType: 'human_feedback', sourceExcerpt: '以后都这样' }];
+    entry.maintenance.learning = { state: 'trial', trialUntil: '2026-01-01T00:00:00.000Z' };
+    addNote('新规则', '新正文')(draft);
+    const freshRule = draft.entries[1];
+    freshRule.origin = 'project_evolution';
+    freshRule.maintenance.learning = { state: 'active', specDigest: 'digest' };
+    return { changed: true };
+  });
+  const first = transact(scope, {}, (draft) => state.applyEvolution(draft, true));
+  assert.equal(first.changed, true);
+  const entries = first.state.entries;
+  assert.equal(entries[0].maintenance.reviewState, 'legacy_unreviewed');
+  assert.equal(entries[0].maintenance.legacyReview.reason, 'scope_unverified');
+  assert.equal(entries[0].current.body, '旧正文');
+  assert.equal(entries[0].maintenance.sourceRefs[0].sourceExcerpt, '以后都这样');
+  assert.equal(entries[0].maintenance.learning.state, 'paused');
+  assert.equal(entries[0].maintenance.learning.blockedReason, 'needs_scope_review');
+  assert.equal(entries[1].maintenance.reviewState, 'active');
+  const second = transact(scope, {}, (draft) => state.applyEvolution(draft, true));
+  assert.equal(second.changed, false, '已复核的不再重复改写');
+});
+
 test('D04 旧程序拒绝写新格式，不抹掉实验标记', () => {
   const scope = fresh('d04-format');
   transact(scope, { expectCreate: true }, (draft) => {
@@ -190,7 +218,9 @@ test('S01 仓库根与子目录共用一份记忆', () => {
   const atSub = scopeOf(sub);
   assert.equal(atSub.key, atRoot.key);
   assert.equal(atSub.dir, atRoot.dir);
-  assert.equal(resolveRoot(sub).root, fs.realpathSync(repo));
+  /* Windows reports the temp root as an 8.3 short name on one side and the long
+     name on the other; compare what both of them resolve to. */
+  assert.equal(fs.realpathSync(resolveRoot(sub).root), fs.realpathSync(repo));
 });
 
 test('S02 符号链接、非 Git 目录、嵌套仓库各归各的', () => {
@@ -600,5 +630,31 @@ test('P0-B 坏 state 且没有 prev：报错给出损坏副本与可执行的恢
   assert.equal(fs.readFileSync(stateFile(scope), 'utf8'), broken);
 });
 
+test('D05 学习开关关掉再开，不重置已用次数和整理记录', () => {
+  const scope = fresh('d05-learning-budget');
+  const at = new Date().toISOString();
+  transact(scope, {}, (draft) => {
+    const evo = draft.experimental.projectEvolution;
+    evo.learning = {
+      attempts: { ep_seed: { count: 2, lastAt: at } },
+      recent: [at],
+      receipts: [{ operationId: 'op_seed', at, inputTokens: 10, outputTokens: 5 }],
+    };
+    return state.applyEvolution(draft, true);
+  });
+  const opened = load(scope).state.experimental.projectEvolution;
+  assert.equal(opened.enabled, true);
+  assert.deepEqual(opened.learning.recent, [], '打开时清掉在途观察');
+  assert.equal(opened.learning.receipts.length, 1, '打开不能清整理回执');
+  assert.equal(opened.learning.attempts.ep_seed.count, 2, '打开不能清已用次数');
+  transact(scope, {}, (draft) => state.applyEvolution(draft, false));
+  transact(scope, {}, (draft) => state.applyEvolution(draft, true));
+  const again = load(scope).state.experimental.projectEvolution;
+  assert.equal(again.enabled, true);
+  assert.equal(again.learning.receipts.length, 1, '关掉再开不重置整理回执');
+  assert.equal(again.learning.attempts.ep_seed.count, 2, '关掉再开不重置已用次数');
+  assert.deepEqual(again.learning.recent, []);
+});
+
 for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true });
 console.log(`state.test.mjs: ${passed} passed`);

package/test/store.test.mjs

@@ -10,7 +10,7 @@ const state = await import('../state.js');
 const { upsert, search, readEntry, forget, undoChange, acceptCandidate, rejectCandidate,
   suggestionGate, noteSuggestion, findSuggestion, renderIndex, normalizeDraft, loadIndex,
   scopeOf, globalScope, LIMITS, recordCitations, listCitations, readCitationBody,
-  evolutionStatus, setEvolution, saveIndex } = store;
+  evolutionStatus, setEvolution, saveIndex, readCitationBodyByTitle } = store;
 
 let passed = 0;
 const test = (name, fn) => {
@@ -219,8 +219,8 @@ test('search finds Chinese queries, when clauses and reports counts', () => {
   const when = search(scope, 'CI 容器');
   assert.ok(when.some((item) => item.title === '文案检查'));
   const rendered = renderIndex(hits);
-  assert.match(rendered.text, /^- mem_[a-z0-9]+ 发布顺序/);
-  assert.match(rendered.text, /mem_[a-z0-9]+ 发布顺序/);
+  assert.match(rendered.text, /^- 「发布顺序」/);
+  assert.doesNotMatch(rendered.text, /mem_[a-z0-9]+/);
   assert.doesNotMatch(rendered.text, /第 .* 版/);
   assert.ok(rendered.chars <= 400);
   assert.deepEqual(search(scope, '完全无关的主题词'), []);
@@ -236,7 +236,8 @@ test('archived or 90-day-stale entries render without a summary', () => {
   assert.equal(hits.length, 1);
   const rendered = renderIndex(hits);
   assert.ok(!rendered.text.includes('｜'), rendered.text);
-  assert.equal(rendered.text.split('\n')[0].includes(item.record.id), true);
+  assert.equal(rendered.text.split('\n')[0].includes(item.record.id), false, '索引行只给标题');
+  assert.match(rendered.text.split('\n')[0], /「旧条目」/);
 });
 
 test('search and read leave hits and lastUsed alone', () => {
@@ -485,7 +486,8 @@ test('projects and the global layer stay separate', () => {
   assert.equal(global.length, 1);
   assert.equal(global[0].scope, 'global');
   const rendered = renderIndex(global);
-  assert.match(rendered.text, /^- \[global\] mem_/);
+  assert.match(rendered.text, /^- \[global\] 「全局条目」/);
+  assert.doesNotMatch(rendered.text, /mem_[a-z0-9]{6,}/);
   const removed = forget(b, 'mem_000000000000', { mode: 'archive' });
   assert.equal(removed, null);
 });
@@ -543,6 +545,16 @@ test('citation rows follow the current title and layer', () => {
   assert.equal(listCitations('session-fresh').items[0].scope, 'global');
 });
 
+test('citation body by title picks the requested layer', () => {
+  const scope = fresh('cite-layer');
+  const local = upsert(scope, { title: '同名规则', summary: '项目层版本', body: '项目正文' }).record;
+  const wide = upsert(globalScope(), { title: '同名规则', summary: '全局层版本', body: '全局正文' }).record;
+  recordCitations(scope, 'session-layer', [{ ...local, scope: 'project' }, { ...wide, scope: 'global' }]);
+  assert.match(readCitationBodyByTitle('session-layer', '同名规则', { scope: 'project' }).body, /项目正文/);
+  assert.match(readCitationBodyByTitle('session-layer', '同名规则', { scope: 'global' }).body, /全局正文/);
+  assert.equal(readCitationBodyByTitle('session-layer', '没有这条', { scope: 'global' }), null);
+});
+
 test('old citation session files are pruned', () => {
   const scope = fresh('cite-prune');
   recordCitations(scope, 'session-old', [{ id: 'mem_000000000001' }]);
@@ -815,6 +827,38 @@ test('项目实验默认关闭；打开才放行实验读取，关闭暂停试
   assert.equal(search(scope, '实验规则', 4).some((row) => row.id === target.id), false);
 });
 
+test('旧实验规则缺作用域指纹时，打开开关只转待复核并保留正文来源', () => {
+  const scope = fresh('evolution-legacy-quarantine');
+  upsert(scope, { title: '旧实验规则', summary: '旧规则的作用域没冻结过', body: '以前留下的正文' });
+  const target = stateOf(scope).entries.find((entry) => entry.current.title === '旧实验规则');
+  assert.ok(target);
+  state.transact(scope, {}, (draft) => {
+    const row = draft.entries.find((entry) => entry.id === target.id);
+    row.origin = 'project_evolution';
+    row.maintenance.learning = { state: 'trial', trialUntil: '2099-01-01T00:00:00.000Z' };
+    row.maintenance.sourceRefs = [{ kind: 'message', id: 'msg_legacy', sessionId: 's-legacy' }];
+    return { changed: true };
+  });
+  const on = setEvolution(scope, true, { operationId: 'op-legacy-on' });
+  assert.equal(on.ok, true);
+  assert.equal(on.changed, true);
+  const row = stateOf(scope).entries.find((entry) => entry.id === target.id);
+  assert.equal(row.current.body, '以前留下的正文');
+  assert.deepEqual(row.maintenance.sourceRefs, [{ kind: 'message', id: 'msg_legacy', sessionId: 's-legacy' }]);
+  assert.equal(row.maintenance.reviewState, 'legacy_unreviewed');
+  assert.equal(row.maintenance.learning.state, 'paused');
+  assert.equal(row.maintenance.learning.blockedReason, 'needs_scope_review');
+  assert.equal(search(scope, '旧实验规则', 4).some((entry) => entry.id === target.id), false);
+  assert.equal(search(scope, '旧实验规则', 4, { allowExperimental: true }).some((entry) => entry.id === target.id), false);
+  const snap = store.learningSnapshot(scope);
+  const shown = snap.rules.find((rule) => rule.title === '旧实验规则');
+  assert.ok(shown, '待复核规则仍要出现在面板里');
+  assert.equal(shown.reviewState, 'legacy_unreviewed');
+  assert.equal(shown.state, 'paused');
+  const again = setEvolution(scope, true);
+  assert.equal(again.changed, false, '重复打开不再产生写入');
+});
+
 test('实验策略版本不认时保持关闭，开关拒绝改动且盘上不变', () => {
   const scope = fresh('evolution-policy');
   upsert(scope, { title: '普通规则', summary: '普通规则', body: '正文' });

package/test/view.test.mjs

@@ -121,6 +121,9 @@ test('触发词进检索与自动召回', () => {
   };
   assert.ok(view.matchScore(record, '帮我把视频贴给我看看').score >= view.MATCH_FLOOR);
   assert.ok(view.matchScore(record, '完全无关的主题词').score < view.MATCH_FLOOR);
+  /** 单字重合不算相关：「这」出现在「这个」里，不能让整句沾边就被召回。 */
+  const unrelated = { id: 'mem_cccccccccccc', title: '以后都用这个一次性脚本', summary: '这个脚本只跑一次', when: '', aliases: [], tags: [], triggers: [], status: 'active' };
+  assert.equal(view.matchScore(unrelated, '把这段视频的字幕导出来').score, 0);
   const ranked = view.rank([record], '帮我把视频贴给我看看', { limit: 4, context: ctxOf(null, {}) });
   assert.equal(ranked.length, 1);
   assert.equal(ranked[0].record.id, record.id);

package/view.js

@@ -234,6 +234,10 @@ export function contextWithTask(context = {}, task = {}) {
 export function eligibility(record, runtime = {}, purpose = 'read', now = Date.now()) {
   if (!record) return { ok: false, status: 'gone', reason: 'gone' };
   if (record.status === 'archived') return { ok: false, status: 'gone', reason: 'archived' };
+  /** 生命周期与手动检索共用一条：被取代或过期的条目不再像现行规则一样进入召回和正文读取。 */
+  if (record.supersededBy) return { ok: false, status: 'gone', reason: 'superseded' };
+  const validUntil = Date.parse(record.validUntil || '');
+  if (Number.isFinite(validUntil) && validUntil <= now) return { ok: false, status: 'gone', reason: 'expired' };
   const pid = runtime && runtime.projectId;
   if (pid && record.ownerProjectId && record.ownerProjectId !== pid) {
     return { ok: false, status: 'not_applicable', reason: 'owner_mismatch' };
@@ -305,20 +309,48 @@ function wordsOf(text) {
   } catch {
     for (const word of plainText.split(/[^\p{L}\p{N}]+/u)) if (word && !STOPWORDS.has(word)) out.push(word);
   }
-  return out.slice(0, 24);
+  /** 本机 ICU 缺中文词典时整句会被切成单字；补上二元组，别让「这」这种单字当整词。 */
+  if (!/[a-z]/i.test(plainText) && out.some((word) => [...word].length === 1)) {
+    const chars = plainText.replace(/[^\p{L}\p{N}]+/gu, '');
+    for (let i = 0; i + 1 < chars.length; i += 1) {
+      const gram = chars.slice(i, i + 2);
+      if (!STOPWORDS.has(gram)) out.push(gram);
+    }
+  }
+  return out.slice(0, 48);
 }
 
 /** 纯英文查询按整词判断：git 不该命中 digital。自动召回和手动搜索共用这一条。 */
 export const asciiWordsOf = (text) => plain(text, 400).toLowerCase().match(/[a-z][a-z0-9_-]{1,}/g) || [];
 export const wordIn = (pool, word) => new RegExp(`(^|[^a-z0-9])${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}($|[^a-z0-9])`).test(pool);
 
-const WEIGHT = { title: 3, keywords: 4, summary: 1.5, when: 1 };
+const WEIGHT = { title: 3, keywords: 4, summary: 1.5, when: 1, coverage: 1.6 };
+
+/** 最长公共连续片段：四个字以上连着重合，是「在说同一件事」的强证据。 */
+function longestRun(text, raw) {
+  /** 只比前 120 个字：够判断「是不是同一句话」，也把每次比对的代价压在常数级。 */
+  const left = plain(text, 120).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '');
+  const right = plain(raw, 120).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '');
+  if (!left || !right) return 0;
+  let best = 0;
+  let prev = new Array(right.length + 1).fill(0);
+  for (let i = 1; i <= left.length; i += 1) {
+    const row = new Array(right.length + 1).fill(0);
+    for (let j = 1; j <= right.length; j += 1) {
+      if (left[i - 1] !== right[j - 1]) continue;
+      row[j] = prev[j - 1] + 1;
+      if (row[j] > best) best = row[j];
+    }
+    prev = row;
+  }
+  return best;
+}
 
 /**
  * 轻量匹配：标题 / 旧标题 / 关键词 / 摘要各算各的分，先过阈值再排序。
  * 排序固定用 id 兜底，同一批数据每次顺序一致。
  */
-export function matchScore(record, query) {
+export function matchScore(record, query, corpus = null) {
   const raw = plain(query, 400);
   if (!raw) return { score: 0, hints: [] };
   if (new RegExp(`\\b${String(record.id).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(raw)) {
@@ -357,16 +389,46 @@ export function matchScore(record, query) {
     score += WEIGHT.keywords;
     hints.push('trigger');
   }
+  /**
+   * 整词命中按字段取一次最大值：一个字/一个词重合只说明沾边，
+   * 每个词各加一次会把分数堆到阈值以上（「这」曾让无关记忆被自动召回）。
+   */
+  /**
+   * 语料里到处都有的词（「触发」「文件」「项目」）只算沾边：
+   * 一条记忆靠这种通用词挤进提示位，真相关的那条就被挤出去了。
+   */
+  const common = (text) => {
+    if (!corpus || !corpus.df || !corpus.total) return false;
+    const df = corpus.df.get(text) || 0;
+    return df > Math.max(3, corpus.total * 0.15);
+  };
+  let titleWordHit = false;
+  let keywordWordHit = false;
+  /** 标题里同时命中的不同实词：两个以上独立概念都落在标题，比只沾一个词更说明在说同一件事。 */
+  const titleWords = new Set();
   for (const word of words) {
+    if ([...word].length < 2) continue;
     const plainWord = word.toLowerCase();
-    const inTitle = plain(record.title, 400).toLowerCase().includes(plainWord)
-      || (record.aliases || []).some((name) => plain(name, 400).toLowerCase().includes(plainWord));
-    const inKeywords = keywordTexts.some((text) => plain(text, 400).toLowerCase().includes(plainWord));
-    if (inTitle || inKeywords) {
-      score += inKeywords ? WEIGHT.keywords : WEIGHT.title;
-      hints.push(inKeywords ? 'keyword' : 'title');
+    if (common(plainWord)) continue;
+    if (keywordTexts.some((text) => plain(text, 400).toLowerCase().includes(plainWord))) { keywordWordHit = true; continue; }
+    if (plain(record.title, 400).toLowerCase().includes(plainWord)
+      || (record.aliases || []).some((name) => plain(name, 400).toLowerCase().includes(plainWord))) {
+      titleWordHit = true;
+      titleWords.add(plainWord);
     }
   }
+  if (!keywordWordHit && titleWordHit) { score += WEIGHT.title; hints.push('title'); }
+  if (keywordWordHit) { score += WEIGHT.keywords; hints.push('keyword'); }
+  if (titleWords.size >= 2) { score += WEIGHT.coverage; hints.push('coverage'); }
+  /** 四字以上的连续重合直接算强命中：句子换了说法但词还连着，就该被想起。 */
+  /** 分已经够的就不必算连续片段；这一步只是补「换了说法但词连着」的情况。 */
+  const run = score >= MATCH_FLOOR ? 0 : Math.max(0, ...[record.title, (record.aliases || []).join(' '), record.summary, record.when]
+    .filter(Boolean)
+    .map((text) => longestRun(text, raw)));
+  if (run >= 4) {
+    score += WEIGHT.title;
+    hints.push('phrase');
+  }
   const summaryScore = hit(record.summary, WEIGHT.summary);
   if (summaryScore > 0) {
     score += summaryScore;
@@ -381,7 +443,7 @@ export function matchScore(record, query) {
       .filter(Boolean).join('\n').toLowerCase();
     if (!ascii.some((word) => wordIn(pool, word))) return { score: 0, hints: [] };
   }
-  return { score, hints };
+  return { score, hints: [...new Set(hints)] };
 }
 
 export const MATCH_FLOOR = 2.4;
@@ -394,6 +456,17 @@ export function rank(records, query, options = {}) {
   const limit = Number.isInteger(options.limit) ? options.limit : 4;
   const context = options.context || {};
   const rows = [];
+  /** 先数一遍词出现在多少条记忆里：通用词降权，只在这批候选内统计，不额外读盘。 */
+  const corpus = { df: new Map(), total: 0 };
+  for (const record of records || []) {
+    if (!record) continue;
+    corpus.total += 1;
+    const seen = new Set();
+    for (const word of wordsOf([record.title, (record.aliases || []).join(' '), (record.tags || []).join(' '), (record.triggers || []).join(' '), record.summary, record.when].filter(Boolean).join(' '))) {
+      seen.add(word.toLowerCase());
+    }
+    for (const word of seen) corpus.df.set(word, (corpus.df.get(word) || 0) + 1);
+  }
   for (const record of records || []) {
     if (!record || record.status === 'archived') continue;
     if (options.requireApplicable && record.reviewState === 'legacy_unreviewed') continue;
@@ -406,7 +479,7 @@ export function rank(records, query, options = {}) {
       status = options.requireApplicable ? statusOf(record, context) : 'ok';
       if (options.requireApplicable && status !== 'ok') continue;
     }
-    const matched = matchScore(record, query);
+    const matched = matchScore(record, query, corpus);
     if (matched.score < MATCH_FLOOR) continue;
     /** 当前任务明确的话题/工作类型优先，但不覆盖查询本身的字面命中。 */
     const task = options.task || {};
@@ -594,7 +667,7 @@ export function newestUserQuery(messages) {
 export function projectionText(view) {
   if (!view) return '';
   const rows = [];
-  rows.push(`${view.title || view.id}${view.when ? `（${view.when}）` : ''} · ${view.id}`);
+  rows.push(`${view.title || '这条记忆'}${view.when ? `（${view.when}）` : ''}`);
   if (view.conditions && view.conditions.length) rows.push(`条件：${view.conditions.map((item) => `${item.key}=${item.value}`).join('，')}`);
   if (view.selection) rows.push(`仅对 ${view.selection} 生效`);
   if (view.state === 'needs_context') rows.push('适用范围待确认');