dsh-lite-memory 0.11.1 → 0.16.2

package/test/evolution-read.test.mjs

@@ -102,7 +102,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
   assert.equal(runtime.debug.windowOf(agent).experiment, null);
 }
 
-/* L02：开关打开但没有任何栏目，先问类型，不猜。 */
+/* L02：开关打开但没有任何栏目，不注入任何领域问题，也不给空上下文。 */
 {
   const dir = mkdir('clarify');
   const scope = scopeOf(dir);
@@ -112,30 +112,50 @@ 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.match(text, /先问用户这期做什么栏目/);
-  assert.match(text, /contextId=ctx_/);
+  assert.equal(text, '');
+  assert.doesNotMatch(text, /栏目|Vlog|口播|视频/);
+  const experiment = runtime.debug.windowOf(agent).experiment;
+  assert.equal(experiment ? experiment.injectedIds.length : 0, 0);
 }
 
 /* L03：未绑定任务只给栏目索引，不超过三条；短规则不进正文。 */
 {
   const dir = mkdir('index');
   const scope = scopeOf(dir);
-  seedRule(scope, { title: '口播开头', body: '开场三句内给结论。', conditions: [{ key: 'seriesId', value: '口播' }] });
-  seedRule(scope, { title: '口播收尾', body: '结尾只留一个行动。', conditions: [{ key: 'seriesId', value: '口播' }] });
+  seedRule(scope, { title: '口播开头', body: '开场三句内给结论。', conditions: [{ key: 'seriesId', value: '口播视频' }] });
+  seedRule(scope, { title: '口播收尾', body: '结尾只留一个行动。', conditions: [{ key: 'seriesId', value: '口播视频' }] });
   seedRule(scope, { title: 'Vlog 节奏', body: '每段不超过二十秒。', conditions: [{ key: 'seriesId', value: 'Vlog' }] });
   enable(scope);
   const runtime = boot();
   const agent = makeAgent('a-index', dir);
   const sig = signal();
-  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期怎么开头')));
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('视频开头怎么改')));
   const text = runtime.text(agent, sig);
-  assert.match(text, /项目里有这些栏目/);
+  assert.match(text, /这些记忆范围可能适用/);
+  assert.doesNotMatch(text, /Vlog/);
   assert.doesNotMatch(text, /开场三句内给结论/);
   const listed = text.split('\n').filter((line) => line.startsWith('- '));
   assert.equal(listed.length <= 3, true);
   assert.equal(Buffer.byteLength(text) <= 600 + 160, true, 'index stays small');
 }
 
+/* L03b：项目有视频栏目，本轮是修代码：无关栏目与选择提示都不进上下文。 */
+{
+  const dir = mkdir('index-unrelated');
+  const scope = scopeOf(dir);
+  seedRule(scope, { title: '口播开头', body: '开场三句内给结论。', conditions: [{ key: 'seriesId', value: '口播' }] });
+  seedRule(scope, { title: 'Vlog 节奏', body: '每段不超过二十秒。', conditions: [{ key: 'seriesId', value: 'Vlog' }] });
+  enable(scope);
+  const runtime = boot();
+  const agent = makeAgent('a-index-unrelated', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('修一下 dsh-unlag 的重新载入问题')));
+  const injected = runtime.text(agent, sig);
+  assert.equal(injected, '');
+  const experiment = runtime.debug.windowOf(agent).experiment;
+  assert.equal(experiment ? experiment.injectedIds.length : 0, 0);
+}
+
 /* L04：项目默认绑定后给规则正文，带 id 与版本。 */
 {
   const dir = mkdir('default');
@@ -150,7 +170,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
   assert.match(text, /项目实验规则/);
   assert.match(text, /先给结论再解释/);
   assert.ok(text.includes(id));
-  assert.match(text, /第 1 版/);
+  assert.doesNotMatch(text, /第 .* 版/);
 }
 
 /* L05：长规则只给用途与 memory_read 指针，不把正文塞进上下文。 */
@@ -247,6 +267,22 @@ const scopeOf = (dir) => store.scopeOf(dir);
   assert.ok(current, 'switch leaves an unbound episode');
 }
 
+/* L09b：明确改为排查数据库后，旧视频规则和栏目提示都不再注入。 */
+{
+  const dir = mkdir('switch-db');
+  const scope = scopeOf(dir);
+  seedRule(scope, { title: '口播开头', body: '开场三句内给结论。', conditions: [{ key: 'seriesId', value: '口播' }] });
+  enable(scope, { seriesId: '口播' });
+  const runtime = boot();
+  const agent = makeAgent('a-switch-db', dir);
+  await runtime.preStep({ agent, signal: signal(), turn: 't1' }, enter(human('这期口播开头')));
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't2' }, enter(human('这期不做了，改为排查 PostgreSQL 慢查询')));
+  const text = runtime.text(agent, sig);
+  assert.equal(text.includes('开场三句内给结论'), false);
+  assert.equal(/栏目|点名/.test(text), false);
+}
+
 /* L10：没有本请求上下文时，普通检索看不到实验来源。 */
 {
   const dir = mkdir('nocx');
@@ -260,7 +296,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
   assert.equal((value.refs || []).some((ref) => ref.id === id), false);
 }
 
-/* L11：带本请求 contextId 才能绑定；绑定后只升到 proposed。 */
+/* L11：真人原话点名栏目就直接生效；工具绑定仍只认这句原话。 */
 {
   const dir = mkdir('bind');
   const scope = scopeOf(dir);
@@ -269,7 +305,7 @@ const scopeOf = (dir) => store.scopeOf(dir);
   const runtime = boot();
   const agent = makeAgent('a-bind', dir);
   const sig = signal();
-  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期怎么开头')));
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期口播怎么开头')));
   const held = runtime.debug.windowOf(agent).experiment;
   assert.ok(held && held.contextId, 'context leaked');
   const value = await runtime.exec('memory_search', { query: '口播', contextId: held.contextId, bindForRequest: true }, agent);
@@ -277,10 +313,30 @@ const scopeOf = (dir) => store.scopeOf(dir);
   assert.ok((value.text || '').includes('口播'));
   const episodes = Object.values(store.taskState(scope).episodes);
   assert.equal(episodes.length, 1);
-  assert.equal(episodes[0].status, 'proposed');
+  assert.equal(episodes[0].status, 'active');
   assert.match(runtime.text(agent, sig), /开场三句内给结论/);
 }
 
+/* L11b：模型自己写 query 不能建绑定；只认本轮真人原话。 */
+{
+  const dir = mkdir('bind-model');
+  const scope = scopeOf(dir);
+  seedRule(scope, { title: '口播开头', body: '开场三句内给结论。', conditions: [{ key: 'seriesId', value: '口播' }] });
+  enable(scope);
+  const runtime = boot();
+  const agent = makeAgent('a-bind-model', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期怎么开头')));
+  const held = runtime.debug.windowOf(agent).experiment;
+  const value = await runtime.exec('memory_search', { query: '口播', contextId: held.contextId, bindForRequest: true }, agent);
+  assert.equal(value.status, 'needs_context');
+  assert.equal((value.text || '').includes('口播'), false);
+  assert.equal((value.text || '').includes('开场三句内给结论'), false);
+  const episodes = Object.values(store.taskState(scope).episodes);
+  assert.equal(episodes.some((episode) => episode.status === 'proposed'), false);
+  assert.equal(runtime.text(agent, sig).includes('开场三句内给结论'), false);
+}
+
 /* L12：跨项目上下文直接拒绝。 */
 {
   const dirA = mkdir('cross-a');
@@ -390,4 +446,133 @@ const scopeOf = (dir) => store.scopeOf(dir);
   assert.equal(text.includes('实验规则：发版前先备份'), false);
 }
 
+/* L18：工具绑定零命中/多命中时只回一句读取状态，不要求用户点名栏目。 */
+{
+  const dir = mkdir('bind-none');
+  const scope = scopeOf(dir);
+  seedRule(scope, { title: '口播开头', body: '开场三句内给结论。', conditions: [{ key: 'seriesId', value: '口播' }] });
+  seedRule(scope, { title: 'Vlog 节奏', body: '每段不超过二十秒。', conditions: [{ key: 'seriesId', value: 'Vlog' }] });
+  enable(scope);
+  const runtime = boot();
+  const agent = makeAgent('a-bind-none', dir);
+  await runtime.preStep({ agent, signal: signal(), turn: 't1' }, enter(human('这期怎么开头')));
+  const held = runtime.debug.windowOf(agent).experiment;
+  const none = await runtime.exec('memory_search', { query: '修一下构建脚本', contextId: held.contextId, bindForRequest: true }, agent);
+  assert.equal(none.status, 'needs_context');
+  assert.doesNotMatch(none.text, /点名|先问|栏目/);
+  const many = await runtime.exec('memory_search', { query: '口播和 Vlog 都要', contextId: held.contextId, bindForRequest: true }, agent);
+  assert.equal(many.status, 'needs_context');
+  assert.doesNotMatch(many.text, /点名|先问|栏目/);
+}
+
+/* L19：试用到期后不再自动注入，和检索、读取用同一档可用性。 */
+{
+  const dir = mkdir('trial-expired');
+  const scope = scopeOf(dir);
+  const id = seedRule(scope, {
+    title: '过期口播规则',
+    body: '这条试用已经到期，不该自动出现。',
+    conditions: [{ key: 'seriesId', value: '口播' }],
+    learning: { state: 'trial', trialUntil: new Date(Date.now() - 60_000).toISOString() },
+  });
+  enable(scope, { seriesId: '口播' });
+  const runtime = boot();
+  const agent = makeAgent('a-trial-expired', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期口播怎么做')));
+  const text = runtime.text(agent, sig);
+  assert.equal(text.includes('这条试用已经到期，不该自动出现。'), false);
+  const held = runtime.debug.windowOf(agent).experiment;
+  assert.deepEqual(held ? held.injectedIds : [], []);
+}
+
+/* L19b：准备时还在试用期、请求中途到期，同一请求也不能再输出正文。 */
+{
+  const dir = mkdir('trial-expiring');
+  const scope = scopeOf(dir);
+  seedRule(scope, {
+    title: '快到期口播规则',
+    body: '这条试用马上到期，过期后同一请求也不能再出现。',
+    conditions: [{ key: 'seriesId', value: '口播' }],
+    learning: { state: 'trial', trialUntil: new Date(Date.now() + 700).toISOString() },
+  });
+  enable(scope, { seriesId: '口播' });
+  const runtime = boot();
+  const agent = makeAgent('a-trial-expiring', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期口播怎么做')));
+  assert.match(runtime.text(agent, sig), /马上到期/);
+  await new Promise((resolve) => setTimeout(resolve, 900));
+  assert.equal(runtime.text(agent, sig), '');
+}
+
+/* L19c：一条试用到期只撤这一条，不把同请求里其他可用规则一起清掉。 */
+{
+  const dir = mkdir('trial-parts');
+  const scope = scopeOf(dir);
+  seedRule(scope, {
+    title: '快到期的主题规则',
+    body: '这条试用马上到期。',
+    conditions: [{ key: 'seriesId', value: '口播' }],
+    learning: { state: 'trial', trialUntil: new Date(Date.now() + 700).toISOString() },
+    topicKey: 'theme',
+  });
+  seedRule(scope, {
+    title: '长期口播开头',
+    body: '开场三句内给结论。',
+    conditions: [{ key: 'seriesId', value: '口播' }],
+    learning: { state: 'active' },
+    topicKey: 'opening',
+  });
+  enable(scope, { seriesId: '口播' });
+  const runtime = boot();
+  const agent = makeAgent('a-trial-parts', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期口播怎么做')));
+  const first = runtime.text(agent, sig);
+  assert.match(first, /快到期的主题规则/);
+  assert.match(first, /长期口播开头/);
+  await new Promise((resolve) => setTimeout(resolve, 900));
+  const later = runtime.text(agent, sig);
+  assert.doesNotMatch(later, /快到期的主题规则/);
+  assert.match(later, /长期口播开头/, '无关的试用到期不该清掉别的规则');
+}
+
+/* L20：自进化关掉后，已经准备好的实验正文立刻不再输出；重开也不复活。 */
+{
+  const dir = mkdir('off-after-prepare');
+  const scope = scopeOf(dir);
+  seedRule(scope, { title: '口播开头', body: '开场三句内给结论。', conditions: [{ key: 'seriesId', value: '口播' }] });
+  enable(scope, { seriesId: '口播' });
+  const runtime = boot();
+  const agent = makeAgent('a-off-after-prepare', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期口播怎么做')));
+  assert.match(runtime.text(agent, sig), /开场三句内给结论/);
+  assert.equal(store.setEvolution(scope, false, { operationId: 'evo-off-after-prepare' }).ok, true);
+  assert.equal(runtime.text(agent, sig), '');
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-on-again' }).ok, true);
+  assert.equal(runtime.text(agent, sig), '');
+}
+
+/* L21：检索没有可用命中、但有条件未确认的候选时，只说状态，不把标题递给模型。 */
+{
+  const dir = mkdir('search-withheld');
+  const scope = scopeOf(dir);
+  save(scope, {
+    title: '发布前检查清单',
+    body: '按清单逐项确认。',
+    summary: '发布前逐项确认',
+    applicability: 'unresolved',
+  });
+  const runtime = boot();
+  const agent = makeAgent('a-search-withheld', dir);
+  const value = await runtime.exec('memory_search', { query: '发布前检查' }, agent);
+  assert.equal(value.count, 0);
+  assert.equal(value.status, 'needs_context');
+  assert.equal(value.reasonCode, 'applicability_unresolved');
+  assert.equal(value.text.includes('发布前检查清单'), false);
+  assert.match(value.text, /适用条件还没确认/);
+}
+
 console.log('evolution-read.test.mjs: all passed');

package/test/learning.test.mjs

@@ -180,7 +180,9 @@ test('B01 调用输入不超过 8 KiB 且只有本地引用', () => {
     ranges: { taskKinds: ['video'], series: ['口播'] },
   });
   assert.ok(input.bytes <= 8192, `bytes=${input.bytes}`);
-  assert.equal(input.rules.length, 6);
+  assert.equal(input.rules.length >= 1, true);
+  assert.equal(input.rules.length <= 6, true);
+  assert.equal(input.prompt.includes(long), false);
   assert.equal(input.refs.feedback.u0, 'm1');
   assert.equal(input.refs.rules.r0, 'mem_0');
   assert.equal(input.messages.length, 1);
@@ -470,7 +472,7 @@ test('P02 两个独立作品后升为已生效，单次只到试用', () => {
   const version = ruleOf(scope, id).revision;
   const rules = [{ ref: 'r0', id, revision: version, conditions: [{ key: 'seriesId', value: '口播' }] }];
   const refs = { feedback: { u0: 'b1' }, rules: { r0: id } };
-  const check = parsed({ target: 'r0', feedbackType: 'spec_change', currentText: '开头三句内先给结论。', evidence: ['u0'] }, { rules, refs });
+  const check = parsed({ target: 'r0', feedbackType: 'spec_change', currentText: NEW_CHANGE.currentText, evidence: ['u0'] }, { rules, refs });
   const second = store.commitLearning(scope, {
     operationId: 'learn_promote',
     epoch: begin(scope, two).epoch,

package/test/lexical.test.mjs

@@ -0,0 +1,33 @@
+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-lexical-'));
+const store = await import('../store.js');
+
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-lexical-scope-'));
+const scope = store.scopeOf(dir);
+const add = (title, extra = {}) => store.upsert(scope, {
+  applicability: 'all_in_scope',
+  body: `正文：${title}`,
+  summary: extra.summary || `${title}的摘要`,
+  tags: extra.tags || [],
+  resolution: 'distinct',
+  title,
+});
+add('digital signal 调试', { tags: ['音频'] });
+add('怎么做发布检查', { tags: ['发布'] });
+add('git 提交前跑检查', { tags: ['git'] });
+
+/* 英文按整词：git 不能因为共享 gi/it 命中 digital。 */
+assert.equal(store.search(scope, 'git', 5).some((row) => row.title.includes('digital')), false);
+assert.equal(store.search(scope, 'digital', 5).some((row) => row.title.includes('digital')), true);
+
+/* 只重合「怎么」这类高频词不算命中。 */
+assert.equal(store.search(scope, '这个怎么弄', 5).length, 0);
+
+/* 实词仍然命中。 */
+assert.equal(store.search(scope, '发布检查', 5).some((row) => row.title.includes('怎么做发布检查')), true);
+
+console.log('lexical.test.mjs: all passed');

package/test/recall.test.mjs

@@ -8,7 +8,7 @@ const { apply } = await import('../index.js');
 const store = await import('../store.js');
 
 const HEADER = '已有记忆可能相关';
-const CARD_LINE = /^- 「.+?」.* · mem_[a-z0-9]+ · 第 \d+ 版/;
+const CARD_LINE = /^- \[[^\]]+\] 「.+?」.* · mem_[a-z0-9]+(?:｜.*)?$/;
 const CARD_LINE_M = new RegExp(CARD_LINE.source, 'm');
 
 const effect = (fn) => {
@@ -122,7 +122,7 @@ for (let i = 0; i < 9; i += 1) {
     summary: '读取预算测试',
     tags: ['大正文'],
     resolution: 'distinct',
-    body: `样本${i + 1}：${'正文内容'.repeat(230)}`,
+    body: `样本${i + 1}：${'正文内容'.repeat(80)}`,
   }));
 }
 
@@ -142,7 +142,7 @@ assert.ok(Buffer.byteLength(preparedText) <= 1200, 'snapshot stays inside card b
 const cards = bootA.provider.text({ agent: agentA, signal: signalA }).split('\n').slice(1);
 assert.ok(cards.length <= 3);
 for (const line of cards) assert.match(line, CARD_LINE);
-assert.match(preparedText, /第 1 版/);
+assert.doesNotMatch(preparedText, /第 .* 版/);
 assert.equal(bootA.provider.text({ agent: agentA, signal: signalA }), preparedText, 'frozen between calls');
 
 // A03：provider 纯内存，不写盘、不动 hits。
@@ -265,7 +265,7 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   await bootA.preStep({ agent, signal: signal(), turn: 't1' }, enter(human('大正文样本怎么用')));
   const first = await bootA.exec('memory_read', { id: bigBodies[0].id }, agent);
   assert.equal(first.status, 'ok');
-  assert.ok(first.body.length > 900);
+  assert.ok(Buffer.byteLength(first.body) > 900);
   const repeat = await bootA.exec('memory_read', { id: bigBodies[0].id }, agent);
   assert.equal(repeat.repeat, true);
   assert.equal(repeat.body, '');
@@ -273,13 +273,15 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   const second = await bootA.exec('memory_read', { id: bigBodies[1].id }, agent);
   assert.equal(second.status, 'ok');
   const third = await bootA.exec('memory_read', { id: bigBodies[2].id }, agent);
-  assert.equal(third.status, 'budget_exhausted');
-  assert.equal(third.body || '', '');
-  assert.equal(third.id, '');
-  assert.equal(bootA.render('memory_read', {}, third), 'memory · 本请求的记忆额度已用完');
+  assert.equal(third.status, 'ok');
+  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 · 本请求的记忆额度已用完');
   const win = bootA.debug.windowOf(agent);
   assert.ok(win.bytes <= 8192);
-  assert.equal(win.bodies, 2);
+  assert.equal(win.bodies, 3);
 
   const agentReads = makeAgent('agent-reads', cwdA);
   await bootA.preStep({ agent: agentReads, signal: signal(), turn: 't1' }, enter(human('大正文样本怎么用')));
@@ -445,3 +447,17 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
 }
 
 console.log('recall.test.mjs: ok');
+
+// A20：条件未确认的条目，model 侧读正文只拿状态，不拿标题；面板仍可查。
+{
+  const agent = makeAgent('agent-withheld-read', cwdA);
+  await prepare(bootA, agent, '发布前要检查什么');
+  const row = await bootA.exec('memory_read', { id: unresolved.id }, agent);
+  assert.equal(row.body, '');
+  assert.equal(row.status, 'needs_context');
+  assert.doesNotMatch(JSON.stringify(row), /发布前要检查什么/);
+  assert.doesNotMatch(bootA.render('memory_read', { id: unresolved.id }, row), /发布前要检查什么/);
+  const links = await bootA.exec('memory_read', { id: unresolved.id, view: 'links' }, agent);
+  assert.equal(links.status, 'needs_context');
+  assert.doesNotMatch(JSON.stringify(links), /发布前要检查什么/);
+}

package/test/state.test.mjs

@@ -210,6 +210,27 @@ test('S02 符号链接、非 Git 目录、嵌套仓库各归各的', () => {
   assert.notEqual(scopeOf(nested).key, scopeOf(repo).key);
 });
 
+test('S03 配置的项目根只覆盖自己的子树，不吞别的目录', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'lm-state-config-'));
+  dirs.push(root);
+  const sub = path.join(root, 'packages', 'app');
+  fs.mkdirSync(sub, { recursive: true });
+  const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'lm-state-outside-'));
+  dirs.push(outside);
+  const config = path.join(memoryRoot(), 'config.json');
+  fs.mkdirSync(path.dirname(config), { recursive: true });
+  fs.writeFileSync(config, JSON.stringify({ projectRoot: root }));
+  try {
+    assert.equal(resolveRoot(sub).root, fs.realpathSync(root));
+    assert.equal(resolveRoot(sub).source, 'configured');
+    assert.equal(scopeOf(sub).key, scopeOf(root).key);
+    assert.notEqual(resolveRoot(outside).source, 'configured');
+    assert.notEqual(scopeOf(outside).key, scopeOf(root).key);
+  } finally {
+    fs.rmSync(config, { force: true });
+  }
+});
+
 test('P04 Git 查询失败不冒充已确认工程，不用 cwd 兜底学习', () => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lm-state-gitfail-'));
   dirs.push(dir);

package/test/store.test.mjs

@@ -40,6 +40,33 @@ const rawState = (scope) => fs.readFileSync(path.join(scope.dir, 'state.json'),
 const countOf = (scope) => loadIndex(scope).entries.length;
 const suggestionsOf = (scope) => loadIndex(scope).suggestions;
 
+test('over-specific body is stored, not rejected for naming concrete values', () => {
+  const scope = fresh('specific');
+  const saved = upsert(scope, {
+    title: '自绘菜单',
+    summary: '菜单用应用自绘，不用系统原生',
+    body: '菜单 z-index: 1100；宽度 min(264px, 100vw - 24px)；字号 12px；内边距 10px；圆角 8px。',
+  });
+  assert.equal(saved.record.title, '自绘菜单');
+  assert.ok(saved.record.body.includes('z-index'));
+});
+
+test('a 500-character body is accepted', () => {
+  const scope = fresh('toolong');
+  const saved = upsert(scope, { title: '长正文', summary: '长一点也要存下来', body: '记'.repeat(500) });
+  assert.equal(saved.record.title, '长正文');
+  assert.equal(saved.record.body.length, 500);
+});
+
+test('正文正好到 4096 字节可以存，元数据不算进正文上限', () => {
+  const scope = fresh('body-cap');
+  const body = `${'测'.repeat(1365)}a`;
+  const saved = upsert(scope, { title: '正文到顶', summary: '正文刚好到上限', body });
+  assert.equal(saved.record.body, body);
+  assert.ok(saved.record.bytes > LIMITS.entryBytes);
+  assert.throws(() => upsert(scope, { title: '超一点', summary: '正文超一点', body: `${body}a` }), /正文 4097 字节/);
+});
+
 test('create then same title merges with full old body kept', () => {
   const scope = fresh('create');
   const first = upsert(scope, { title: '发布顺序', summary: '发版前要按顺序做的事', body: '第一步\n- 跑测试' });
@@ -126,16 +153,20 @@ test('oversized body is rejected, old data untouched', () => {
   assert.equal(loadIndex(scope).entries[0].revision, 1);
 });
 
-test('over-long title and summary are errors, not silent slices', () => {
+test('over-long title is an error; over-long summary is truncated but the full text is saved', () => {
   const scope = fresh('length');
   assert.throws(() => upsert(scope, { title: 't'.repeat(LIMITS.titleChars + 1), summary: '写得短一点' }), /标题超过/);
-  assert.throws(() => upsert(scope, { title: '长摘要', summary: 's'.repeat(LIMITS.summaryChars + 1) }), /摘要超过/);
-  assert.equal(fs.existsSync(path.join(scope.dir, 'state.json')), false);
+  const long = '长'.repeat(LIMITS.summaryChars + 1);
+  const saved = upsert(scope, { title: '长摘要', summary: long });
+  assert.equal(saved.record.summary.length, LIMITS.summaryChars);
+  assert.equal(readEntry(scope, saved.record.id).body, long);
+  assert.equal(saved.draft.fullTextInBody, true);
+  assert.equal(saved.draft.summaryShortened, true);
 });
 
-test('imperative summary and credentials are rejected', () => {
+test('imperative summary is kept; credentials are still rejected', () => {
   const scope = fresh('validate');
-  assert.throws(() => upsert(scope, { title: '回复语言', summary: '请用中文回复' }), /名词短语/);
+  assert.equal(upsert(scope, { title: '回复语言', summary: '请用中文回复' }).record.summary, '请用中文回复');
   assert.throws(() => upsert(scope, { title: '凭据', summary: '一个 token 的值', body: 'token = sk-abcdefghijklmnopqrst' }), /凭据/);
   assert.equal(normalizeDraft({ title: 'a', summary: '名词短语' }).kind, 'note');
   assert.throws(() => normalizeDraft({ title: 'a', summary: '名词短语', kind: 'guess' }), /类型只能是/);
@@ -185,7 +216,8 @@ test('search finds Chinese queries, when clauses and reports counts', () => {
   assert.ok(when.some((item) => item.title === '文案检查'));
   const rendered = renderIndex(hits);
   assert.match(rendered.text, /^- mem_[a-z0-9]+ 发布顺序/);
-  assert.match(rendered.text, /第 1 版/);
+  assert.match(rendered.text, /mem_[a-z0-9]+ 发布顺序/);
+  assert.doesNotMatch(rendered.text, /第 .* 版/);
   assert.ok(rendered.chars <= 400);
   assert.deepEqual(search(scope, '完全无关的主题词'), []);
 });
@@ -448,7 +480,7 @@ 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, /^- \[全局\] mem_/);
+  assert.match(rendered.text, /^- \[global\] mem_/);
   const removed = forget(b, 'mem_000000000000', { mode: 'archive' });
   assert.equal(removed, null);
 });
@@ -731,7 +763,8 @@ test('实验来源条目默认不进入检索、正文与关联，只有管理
   });
   assert.equal(search(scope, '实验记录', 4).some((row) => row.id === target.id), false);
   assert.equal(readEntry(scope, target.id), null);
-  assert.equal(search(scope, '实验记录', 4, { allowExperimental: true }).some((row) => row.id === target.id), true);
+  assert.equal(search(scope, '实验记录', 4, { allowExperimental: true }).some((row) => row.id === target.id), false);
+  assert.equal(search(scope, '实验记录', 4, { allowExperimental: true, history: true }).some((row) => row.id === target.id), true);
   assert.equal(readEntry(scope, target.id, { allowExperimental: true }).body, '实验正文');
   assert.ok(readEntry(scope, normal.record.id));
 });
@@ -794,5 +827,62 @@ test('实验策略版本不认时保持关闭，开关拒绝改动且盘上不
   assert.equal(fs.readFileSync(path.join(scope.dir, 'state.json'), 'utf8'), before);
 });
 
+test('当前不适用的高相关条目不挤掉后面真能用的条目', () => {
+  const scope = fresh('usable-rank');
+  for (let index = 0; index < 40; index += 1) {
+    upsert(scope, {
+      title: `旧规则${index}`,
+      summary: `旧规则${index}`,
+      body: `口播检查项${index}的正文`,
+      applicability: 'unresolved',
+    });
+  }
+  const usable = upsert(scope, {
+    title: '口播检查项可用',
+    summary: '口播检查项可用',
+    body: '口播检查项的可用正文',
+    applicability: 'all_in_scope',
+  });
+  const usableId = usable.record?.id ?? usable.id;
+  const hits = search(scope, '口播检查项', 3);
+  assert.equal(hits.some((row) => row.id === usableId), true);
+});
+
 for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true });
+
+test('R24 省略正文的更新不覆盖已有正文（按 id 与同名都成立）', () => {
+  const scope = fresh('omit-body');
+  const first = upsert(scope, { title: '连接池改法', summary: '旧摘要', body: '旧正文：先看连接数。' });
+  const id = first.record.id;
+  upsert(scope, { id, title: '连接池改法', summary: '新摘要' });
+  assert.equal(bodyOf(scope, id), '旧正文：先看连接数。', 'id 更新省略正文时保留原正文');
+  upsert(scope, { title: '连接池改法', summary: '再新一点' });
+  assert.equal(bodyOf(scope, id), '旧正文：先看连接数。', '同名更新省略正文时保留原正文');
+});
+
+test('R25 长摘要改动即使只差第 61 个字符也算改过，全文仍保留', () => {
+  const scope = fresh('long-summary-change');
+  const head = '摘要主体'.repeat(15);
+  const first = upsert(scope, { title: '长摘要规则', summary: `${head}甲` });
+  const id = first.record.id;
+  assert.equal(first.record.summary.length, LIMITS.summaryChars);
+  assert.match(bodyOf(scope, id), /甲$/);
+  const again = upsert(scope, { id, title: '长摘要规则', summary: `${head}乙` });
+  assert.equal(again.noop, false, '第 61 个字符变化不能当作没改');
+  const body = bodyOf(scope, id);
+  assert.match(body, /甲/);
+  assert.match(body, /乙/, '新的完整摘要也落盘');
+  assert.equal(again.record.summary.length, LIMITS.summaryChars);
+});
+
+test('R26 显式长正文加短摘要时补上摘要原文，不把两者混成一条', () => {
+  const scope = fresh('body-plus-summary');
+  const long = '现场记录'.repeat(20);
+  const saved = upsert(scope, { title: '带正文的长摘要', summary: long, body: '显式正文：先复现再改。' });
+  const body = bodyOf(scope, saved.record.id);
+  assert.match(body, /^显式正文：先复现再改。/);
+  assert.match(body, /摘要原文：/);
+  assert.match(body, /现场记录/);
+});
+
 console.log(`store.test.mjs: ${passed} passed`);

package/view.js

@@ -222,6 +222,21 @@ export function canAutoRecall(record, context) {
   return statusOf(record, context) === 'ok';
 }
 
+/**
+ * 学习规则是否还在有效期内：paused/pending 和被时间淘汰的 trial 都不能当依据。
+ * 只对实验来源生效；普通记忆不看这一层。
+ */
+export function experimentalUsable(record, now = Date.now()) {
+  if (!record) return false;
+  const learning = record.learning && typeof record.learning === 'object' ? record.learning : null;
+  if (!learning && record.origin !== 'project_evolution') return true;
+  if (!learning) return false;
+  if (learning.state === 'active') return true;
+  if (learning.state !== 'trial') return false;
+  const until = Date.parse(String(learning.trialUntil || ''));
+  return !Number.isFinite(until) || until > Number(now);
+}
+
 function gramsOf(text) {
   const plainText = plain(text, 400).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '');
   const set = new Set();
@@ -511,7 +526,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} · 第 ${view.revision || 1} 版`);
+  rows.push(`${view.title || view.id}${view.when ? `（${view.when}）` : ''} · ${view.id}`);
   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('适用范围待确认');