dsh-lite-memory 0.15.0 → 0.16.2

package/store.js

@@ -27,7 +27,6 @@ const SECRET_PATTERNS = [
 ];
 
 /** A summary is a noun phrase. An imperative turns a note into an instruction. */
-const IMPERATIVE = /^(?:你要|你得|你必须|请|务必|必须|记得|记住|别忘了|do not|don't|please|you (?:must|should|need))/i;
 
 const SUGGESTION_ID = /^sug_[a-z0-9]{6,}$/;
 
@@ -276,19 +275,9 @@ function cleanTitle(value) {
   return String(value ?? '').replace(/\s+/g, ' ').trim();
 }
 
-/** 正文里的实现参数（尺寸/层级/字号）不算记忆：数到三次就要求重写成原则。 */
-const UI_SPEC_PATTERNS = [
-  /\bz-index\s*:\s*-?\d+/gi,
-  /\b(?:padding|margin|gap|font-size|line-height|border-radius|width|height|min-width|max-width|min-height|max-height|box-shadow)\s*:[^;\n]{0,32}\d/gi,
-  /\b\d+(?:\.\d+)?(?:px|rem|em)\b/gi,
-  /\bmin\(\s*\d/gi,
-];
-
 export function validSummary(summary) {
-  const text = String(summary ?? '').replace(/\s+/g, ' ').trim();
+  const text = String(summary ?? '').replace(/\s+/g, ' ').trim().slice(0, LIMITS.summaryChars);
   if (!text) return { ok: false, reason: '摘要为空' };
-  if (text.length > LIMITS.summaryChars) return { ok: false, reason: `摘要超过 ${LIMITS.summaryChars} 字，先写短些` };
-  if (IMPERATIVE.test(text)) return { ok: false, reason: '摘要必须写成名词短语，不能写成指令' };
   return { ok: true, text };
 }
 
@@ -308,25 +297,32 @@ export function normalizeDraft(source, options = {}) {
   const mayOmitTitle = Boolean(id);
   if (!title && !mayOmitTitle) throw new Error('标题为空');
   let summary = '';
+  let summaryShortened = false;
   const rawSummary = String(draft.summary ?? '').replace(/\s+/g, ' ').trim();
   if (rawSummary) {
     const check = validSummary(rawSummary);
     if (!check.ok) throw new Error(check.reason);
     summary = check.text;
+    summaryShortened = summary.length < rawSummary.length;
   } else if (has('summary')) {
     throw new Error('摘要为空');
   }
   /** 更新（带 id）与候选草稿允许省略摘要；省略表示保持原值，不拿标题补。 */
   const mayOmitSummary = options.requireSummary === false || Boolean(id);
   if (!summary && !mayOmitSummary) throw new Error('摘要为空');
-  const body = String(draft.body ?? '').trim();
-  const bodyBytes = Buffer.byteLength(body);
+  /**
+   * 正文是否由调用方显式给出，和「摘要太长所以自动补一份」必须分开。
+   * 否则同名更新会被自动补出的正文当成显式覆盖，把原正文冲掉。
+   */
+  const bodyExplicit = has('body');
+  const body = bodyExplicit ? String(draft.body ?? '').trim() : '';
+  const autoBody = !bodyExplicit && summaryShortened ? rawSummary : '';
+  const checked = bodyExplicit ? body : autoBody;
+  const bodyBytes = Buffer.byteLength(checked);
   if (bodyBytes > LIMITS.entryBytes) {
-    throw new Error(`正文 ${bodyBytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；只留原则、判断规则和触发条件`);
-  }
-  if (has('body')) {
-    const concrete = UI_SPEC_PATTERNS.reduce((count, pattern) => count + (body.match(pattern) || []).length, 0);
-    if (concrete >= 3) throw new Error('正文太具体：记忆只留原则和触发条件，像素、字号、层级这类实现参数留在代码或文档里');
+    throw new Error(autoBody
+      ? `摘要 ${rawSummary.length} 字，超过单条 ${LIMITS.entryBytes} 字节；先拆成两条写，别丢后半段`
+      : `正文 ${bodyBytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；只留原则、判断规则和触发条件`);
   }
   const kind = has('kind') ? textField(draft.kind, 20, '类型') : 'note';
   if (kind && !KINDS.includes(kind)) throw new Error(`类型只能是 ${KINDS.join(' / ')}`);
@@ -349,6 +345,10 @@ export function normalizeDraft(source, options = {}) {
     summary,
     when,
     body,
+    summaryShortened,
+    summaryRaw: rawSummary,
+    autoBody,
+    fullTextInBody: false,
     kind: kind || 'note',
     tags,
     triggers,
@@ -361,7 +361,7 @@ export function normalizeDraft(source, options = {}) {
       title: has('title') && Boolean(title),
       summary: has('summary'),
       when: has('when'),
-      body: has('body'),
+      body: bodyExplicit,
       kind: has('kind'),
       tags: has('tags'),
       triggers: triggers !== undefined,
@@ -651,6 +651,14 @@ function rulesOf(draft, body, index, foreign) {
   return rules;
 }
 
+/** 长摘要的尾部不能丢：正文里没有这段时补在末尾，已有则不动。 */
+function bodyWithSummaryTail(body, draft) {
+  const raw = String(draft.summaryRaw || '');
+  const current = String(body || '');
+  if (!raw || !draft.summaryShortened || current.includes(raw)) return { body: current, added: false };
+  return { body: current ? `${current}\n\n摘要原文：${raw}` : raw, added: true };
+}
+
 function mergedFields(draft, record, oldBody, index, writeMode = 'patch', foreign) {
   if (writeMode === 'replace_current') {
     const next = {
@@ -664,8 +672,9 @@ function mergedFields(draft, record, oldBody, index, writeMode = 'patch', foreig
       selection: draft.has.selection ? draft.selection : null,
       links: draft.has.links ? draft.links : [],
       topicKey: draft.has.topicKey ? draft.topicKey : '',
-      body: draft.body,
+      body: bodyWithSummaryTail(draft.body, draft).body,
     };
+    if (next.body !== draft.body) draft.fullTextInBody = true;
     next.applicability = view.validateApplicability(draft.has.applicability ? draft.applicability : undefined,
       next.conditions, next.selection, next.when);
     assertLinksVisible(next.links, index, foreign);
@@ -743,6 +752,9 @@ function applyDraft(scope, index, source, now, options = {}) {
   if (record) {
     const oldBody = readBody(scope, record.id);
     const next = mergedFields(draft, record, oldBody, index, writeMode, foreign);
+    const tail = bodyWithSummaryTail(next.body, draft);
+    next.body = tail.body;
+    if (tail.added) draft.fullTextInBody = true;
     const noop = next.title === record.title && next.summary === record.summary
       && next.when === (record.when || '') && next.kind === (record.kind || 'note')
       && JSON.stringify(next.tags) === JSON.stringify(record.tags || [])
@@ -777,7 +789,11 @@ function applyDraft(scope, index, source, now, options = {}) {
     return { record, merged: true, mergedFrom, similar: null, similarList, draft, noop: false, previousBody: oldBody, archived };
   }
   if (writeMode === 'replace_current') throw new Error('整份替换要先指明是哪条，不能用来新增');
-  const rules = rulesOf(draft, draft.body, index, foreign);
+  const seed = draft.autoBody || draft.body;
+  const tail = bodyWithSummaryTail(seed, draft);
+  const createdBody = tail.body;
+  if (tail.added || draft.autoBody) draft.fullTextInBody = true;
+  const rules = rulesOf(draft, createdBody, index, foreign);
   const created = {
     id: newId(),
     title: draft.title,
@@ -791,7 +807,7 @@ function applyDraft(scope, index, source, now, options = {}) {
     selection: rules.selection,
     links: rules.links,
     topicKey: rules.topicKey,
-    body: draft.body,
+    body: createdBody,
     aliases: [],
     created: now,
     updated: now,
@@ -817,8 +833,9 @@ function applyDraft(scope, index, source, now, options = {}) {
  * 结果经 index.__archived 回填，调用方在工具结果里点名。
  */
 function assertFits(scope, index, record) {
-  if (record.bytes > LIMITS.entryBytes) {
-    throw new Error(`这一条 ${record.bytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；先精简正文`);
+  const bodyBytes = Buffer.byteLength(record.body || '');
+  if (bodyBytes > LIMITS.entryBytes) {
+    throw new Error(`正文 ${bodyBytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；先精简正文`);
   }
   const size = recordSize(record);
   if (size > LIMITS.recordBytes) {
@@ -1073,8 +1090,11 @@ export function search(scope, query, limit = 4, options = {}) {
       const group = resolved.get(view.topicSlot(item));
       return Boolean(group && group.status === 'ok' && group.record && group.record.id !== item.id);
     };
-    const visible = rows.filter((row) => row.archived || !shadowed(row.item));
-    visible.sort((a, b) => b.score - a.score
+    const visible = rows.filter((row) => row.archived || !shadowed(row.item))
+      .map((row) => ({ ...row, usable: row.archived || view.statusOf(row.item, options.context || {}) === 'ok' }));
+    /** 先按「本轮能不能用」分组再按相关度：高相关但当前不适用的条目不能挤掉后面真正能用的。 */
+    visible.sort((a, b) => Number(b.usable) - Number(a.usable)
+      || b.score - a.score
       || Number(a.archived) - Number(b.archived)
       || String(b.item.lastUsed).localeCompare(String(a.item.lastUsed)));
     const chosen = visible.slice(0, limit);
@@ -1255,13 +1275,16 @@ function findCurrent(id, scope, options = {}) {
     const record = index.entries.find((item) => item.id === id && item.status !== 'archived');
     if (!record) continue;
     if (!readableRecord(record, options, index)) continue;
+    /** 关联目标也按本轮上下文判适用；条件未知、过期或暂停的目标不给标题。 */
+    if (view.statusOf(record, options.context || {}) !== 'ok') continue;
+    if (isExperimentalRecord(record) && !view.experimentalUsable(record, options.now)) continue;
     return {
       id: record.id,
       title: record.title,
       summary: record.summary || '',
       scope: source.key === 'global' ? 'global' : 'project',
       revision: record.revision || 1,
-      status: view.statusOf(record, {}),
+      status: 'ok',
     };
   }
   return null;
@@ -2643,7 +2666,7 @@ export function commitLearning(scope, batch = {}) {
               touched += 1;
               continue;
             }
-            if (currentRules.length + (touched + 1) > learning.LIMITS.rules) throw new Error('项目实验规则已经到上限');
+            if (currentRules.length + 1 > learning.LIMITS.rules) throw new Error('项目实验规则已经到上限');
             const pending = currentRules.filter((entry) => toFlat(entry).learning?.state === 'pending').length;
             if (pending >= learning.LIMITS.pending) throw new Error('待确认候选已经到上限');
             merged.learning = {
@@ -2906,15 +2929,18 @@ export function editLearningRule(scope, id, options = {}) {
         const nextBody = body || flat.body;
         if (nextTitle === flat.title && nextBody === flat.body) return { changed: false };
         const nextCurrent = { ...entry.current, title: nextTitle, body: nextBody };
+        const bodyChanged = nextBody !== flat.body;
         const learningState = { ...(flat.learning || {}) };
         if (!learningState.specDigest) learningState.specDigest = learning.specDigestOf(flat);
-        learningState.versions = [...(Array.isArray(learningState.versions) ? learningState.versions : []),
-          { digest: learningState.specDigest, body: flat.body, at }].slice(-learning.LIMITS.versions);
+        if (bodyChanged) {
+          learningState.versions = [...(Array.isArray(learningState.versions) ? learningState.versions : []),
+            { digest: learningState.specDigest, body: flat.body, at }].slice(-learning.LIMITS.versions);
+          learningState.supportedEpisodeIds = [];
+          learningState.evidence = [];
+        }
         learningState.specDigest = learning.specDigestOf(nextCurrent);
-        learningState.supportedEpisodeIds = [];
-        learningState.evidence = [];
         learningState.updatedAt = at;
-        if (learningState.state === 'active') {
+        if (bodyChanged && learningState.state === 'active') {
           learningState.state = 'trial';
           learningState.trialUntil = new Date(now + learning.LIMITS.trialMs).toISOString();
         }

package/test/anchor.test.mjs

@@ -434,3 +434,93 @@ test('R28 指代加动作的续接仍保留旧任务范围', () => {
   assert.equal(next.anchor.episodeId, previous.episodeId);
   assert.equal(next.anchor.seriesId, '口播');
 });
+
+test('R29 带「继续改」但对象换成新的英文主题时撤销旧范围', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_switch_pg_continue',
+    messageIds: ['m2'],
+    query: '继续改 PostgreSQL 连接池配置',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+  assert.equal(next.anchor.seriesId, undefined);
+});
+
+test('R30 带「调整一下」但对象换了时撤销旧范围', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_switch_pg_adjust',
+    messageIds: ['m2'],
+    query: '调整一下 PostgreSQL 连接池配置',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+});
+
+test('R31 带「继续改」但明确指向新对象动作时撤销旧范围', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_switch_db_code',
+    messageIds: ['m2'],
+    query: '继续改数据库连接超时的处理代码',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+});
+
+/** 复核复现：句首带「继续」不能成为沿用旧正文的通行证。 */
+for (const [label, query] of [
+  ['R32 继续改数据库连接池配置', '继续改数据库连接池配置'],
+  ['R33 继续优化数据库连接池', '继续优化数据库连接池'],
+  ['R34 继续写数据库故障报告', '继续写数据库故障报告'],
+  ['R35 这个数据库连接池配置怎么改', '这个数据库连接池配置怎么改'],
+]) {
+  test(`${label}：与旧任务没有对象交集时不继承旧范围`, () => {
+    const tasks = activeVideoSession();
+    const next = anchor.routeTask(tasks, {
+      sessionId: 'sess-switch',
+      batchKey: `rb_${label.slice(0, 3)}_db`,
+      messageIds: ['m2'],
+      query,
+      registeredSeries: ['口播'],
+      now: 2000,
+    });
+    assert.equal(next.decision.kind, 'unbound');
+    assert.equal(next.decision.reason, 'new_task');
+    assert.equal(next.anchor.seriesId, undefined);
+  });
+}
+
+test('R41 旧稿提到但明确换到排查任务时不再绑定旧栏目', () => {
+  const tasks = activeVideoSession();
+  for (const query of ['排查 PostgreSQL 连接池故障，旧稿先放着', '这版数据库连接池配置怎么改']) {
+    const next = anchor.routeTask(tasks, {
+      sessionId: 'sess-switch',
+      batchKey: `rb_${query.length}`,
+      messageIds: ['m2'],
+      query,
+      registeredSeries: ['口播'],
+      now: 2000,
+    });
+    assert.equal(next.decision.kind, 'unbound', query);
+    assert.equal(next.anchor.seriesId, undefined, query);
+  }
+});
+
+test('R42 栏目只被提到、否定或搁置时都不算用户选中', () => {
+  assert.equal(anchor.seriesChosenBy('把口播开头改一下', '口播'), true);
+  assert.equal(anchor.seriesChosenBy('先不做口播了', '口播'), false);
+  assert.equal(anchor.seriesChosenBy('不要按口播的规矩来', '口播'), false);
+  assert.equal(anchor.seriesChosenBy('日志里提到口播吗', '口播'), false);
+  assert.equal(anchor.seriesChosenBy('先放着口播，改数据库', '口播'), false);
+});

package/test/control.test.mjs

@@ -235,6 +235,25 @@ const toggle = (scope, enabled) => store.setMemoryEnabled(scope, enabled, { oper
   assert.equal(afterAdopt.title, '口播结论前置');
 }
 
+/* C07b：只改标题不动正文时保留生效状态与学习依据。 */
+{
+  const dir = mkdir('title-only');
+  const scope = scopeOf(dir);
+  const id = seedRule(scope, '口播开头');
+  state.transact(scope, {}, (draft) => {
+    const row = draft.entries.find((entry) => entry.id === id);
+    row.maintenance.learning = { state: 'active', evidence: [{ text: '三次口播都先改开头' }] };
+    return { changed: true };
+  });
+  const first = store.learningSnapshot(scope).rules[0];
+  const edited = store.editLearningRule(scope, id, { expectedRevision: first.revision, title: '口播开头重命名' });
+  assert.equal(edited.ok, true);
+  const after = store.learningSnapshot(scope).rules[0];
+  assert.equal(after.state, 'active');
+  assert.equal(after.learning.evidence.length, 1);
+  assert.equal(after.title, '口播开头重命名');
+}
+
 /* C08：关闭保留已消耗额度与默认绑定，重开后仍按原额度限额。 */
 {
   const dir = mkdir('preserve-quota');

package/test/evolution-read.test.mjs

@@ -296,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);
@@ -305,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);
@@ -313,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');
@@ -445,4 +465,114 @@ const scopeOf = (dir) => store.scopeOf(dir);
   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/recall.test.mjs

@@ -447,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/store.test.mjs

@@ -40,24 +40,31 @@ 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 rejected instead of becoming a constraint', () => {
+test('over-specific body is stored, not rejected for naming concrete values', () => {
   const scope = fresh('specific');
-  assert.throws(
-    () => upsert(scope, {
-      title: '自绘菜单',
-      summary: '菜单用应用自绘，不用系统原生',
-      body: '菜单 z-index: 1100；宽度 min(264px, 100vw - 24px)；字号 12px；内边距 10px；圆角 8px。',
-    }),
-    /正文太具体/,
-  );
+  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('body over the distilled budget is rejected', () => {
+test('a 500-character body is accepted', () => {
   const scope = fresh('toolong');
-  assert.throws(
-    () => upsert(scope, { title: '长正文', summary: '太长就不存', body: '记'.repeat(500) }),
-    /超过单条 1200 字节/,
-  );
+  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', () => {
@@ -146,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' }), /类型只能是/);
@@ -816,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`);