dsh-lite-memory 0.15.0 → 0.16.2

package/README.md

@@ -23,7 +23,7 @@ Lightweight memory for the DeepSeek Harness. No standing system prompt, nothing
 
 写入时分两层：默认只在这个项目生效；用户说「以后所有项目都这样」才进全局层（200 条起提示，硬上限 1000 条），检索时一起查。同一主题在不同前提下用 `when` 区分，各存一条。
 
-写入前先蒸馏：标题是结论，正文只留原则、判断规则和触发条件，不把具体尺寸、字号、层级、颜色或一次性数字记进来；需要这些值时按记忆里的指针查当前代码或文档。单条正文超过 1200 字节会被拒绝，先删细节再存。
+写入前先蒸馏：标题是结论，正文只留原则、判断规则和触发条件，不把具体尺寸、字号、层级、颜色或一次性数字记进来；需要这些值时按记忆里的指针查当前代码或文档。单条正文超过 4096 字节会被拒绝，先删细节再存；摘要超长自动截到 60 字。
 
 触发词：`记住`、`记一下`、`上次`、`规范`、`约定`、`路径`、`凭据怎么取`。
 
@@ -39,7 +39,7 @@ Those lines belong to the turn that made them: each turn is rebuilt from its own
 
 Writes land in one of two layers: the current project by default, or the global layer (warns past 200, hard ceiling 1000) when the user says the rule holds for every project. Both layers are searched together, and a `when` field separates the same subject under different preconditions.
 
-Before writing, distill: the title is the conclusion and the body keeps only the principle, decision rule and trigger condition. Concrete dimensions, font sizes, z-index, colors and one-off numbers stay out; the memory points at where to read the current value instead. A body over 1200 bytes is refused, so drop detail before saving.
+Before writing, distill: the title is the conclusion and the body keeps only the principle, decision rule and trigger condition. Concrete dimensions, font sizes, z-index, colors and one-off numbers stay out; the memory points at where to read the current value instead. A body over 4096 bytes is refused, so drop detail before saving; an over-long summary is truncated to 60 characters.
 
 ## 点一下就存 / One click, no turn
 
@@ -80,13 +80,13 @@ On the Memories tab, the search row also switches between list and graph; either
 - **0 依赖**，存储层无定时器、无监听、无网络，只有同步单文件写；写入用一把有超时的锁，别的进程正在写就明确报「忙」，不抢别人的锁。
 - 搜索最多 4 条、400 字；正文只在 `memory_read` 里出现，全文永不进上下文。
 - 普通检索只列当前有效的记录；已经归档或被更新替换的旧说法不混进来，要查历史得在 `memory_search` 里显式要 `history`。
-- 上限：单条正文 1200 字节、整库正文 512 KB、每层 1000 条、标题与摘要各 60 字；每层 200 条只当提示线。90 天未用只留 `id + 标题`。到了硬上限不拒绝新记忆：把同层最久没被读的一条移进归档，保存结果里写明是哪条（正文与完整记录都留着，可人工取回），单条本身超预算才报错；用户明确说「别记」也进归档。文件从不删除。
+- 上限：单条正文 4096 字节、整库正文 1 MB、每层 1000 条、标题与摘要各 60 字；每层 200 条只当提示线。90 天未用只留 `id + 标题`。到了硬上限不拒绝新记忆：把同层最久没被读的一条移进归档，用户固定过的规则不动，保存结果里写明是哪条（正文与完整记录都留着，可人工取回），单条本身超预算才报错；用户明确说「别记」也进归档。文件从不删除。
 - 一个项目一个目录，项目之间互相看不见。
 
 - **Zero dependencies.** The store has no timers, no listeners, no network — just synchronous single-file writes, guarded by a lock that gives up after 500 ms instead of stealing it.
 - Search returns at most 4 hits and 400 characters. Full text only appears in `memory_read`.
 - Normal search lists current entries only; archived notes and superseded wording stay out unless `memory_search` asks for `history`.
-- Limits: 1200 bytes per body, 512 KB of bodies per store, 1000 entries per layer, 60 characters per title or summary; 200 entries per layer is just a warning line. At the hard ceiling a save is never refused: the least recently read entry in the same layer moves to archive and the result names it (body and full record kept, restorable by hand); only an entry that alone exceeds the budget fails. Saying 「别记」 also archives. Files are never deleted.
+- Limits: 4096 bytes per body, 1 MB of bodies per store, 1000 entries per layer, 60 characters per title or summary; 200 entries per layer is just a warning line. At the hard ceiling a save is never refused: the least recently read entry in the same layer moves to archive (pinned rules are never evicted) and the result names it (body and full record kept, restorable by hand); only an entry that alone exceeds the budget fails. Saying 「别记」 also archives. Files are never deleted.
 - One directory per project, so projects never see each other's notes.
 
 ## 项目自进化〔实验〕 / Project self-evolution (experimental)

package/anchor.js

@@ -16,12 +16,22 @@ const REFERENCE_WORDS = /(这个|这条|这次|上次|之前|刚才|上面|前
 const TASK_STOP = new Set(['一个','一下','这个','那个','我们','你们','他们','什么','怎么','可以','需要','帮我','帮忙','请问','然后','现在','还是','就是','没有','不是','以及','关于','进行','使用','问题','任务','内容','时候','已经','如果','因为','所以','但是','而且','或者','这些','那些','这样','那样','一下','一点','一些']);
 /** 判断任务是否换了对象时，这些词只表示动作或指代，不算对象证据。 */
 const TASK_NOISE = /(继续|再做一期|下一期|再来一期|再开一期|续一集|再拍一期|接着|然后|接下来|现在|帮我|帮忙|这个|这条|这次|上次|之前|刚才|上面|前面|下面|后面|这里|还是|同样|再改|排查|处理|检查|看看|看一下|看下|修复|解决|优化|调整|修改|分析|研究|对比|评估|调研|测试|设计|实现|开发|搭建|部署|定位|复现|查一下|找一下|问题|任务|内容|一下)/g;
-const NEW_OBJECT_VERB = /(排查|检查|看看|看一下|看下|分析|研究|对比|评估|调研|测试|设计|实现|开发|搭建|部署|修复|解决|处理|定位|复现|查一下|找一下)/;
-const NEW_TASK_MARKER = /(现在|接下来|然后|下面|新任务|另一个|重新|改做|换个|换一个)/;
 /** 续接词后面还得跟一个动作，才算真正在改旧稿；单说「继续 / 这个 / 之前」不构成复用依据。 */
 const CONTINUATION_ACTION = /(继续|接着|然后|再|还是|同样)\s*(做|改|调|弄|看|写|处理|优化|调整|检查|完成)/;
+/** 明确指向刚才那一版作品的说法，是沿用旧范围的正面证据；「这版/那版」只是指示，不算旧稿。 */
+const OLD_WORK_REFERENCE = /(刚才那版|之前那版|上一版|原稿|旧稿)/;
+/** 旧稿被放下、否定或只作为话题提起时，不能因为它出现就恢复旧范围。 */
+const OLD_WORK_PAUSE = /(先放着|放着|放一边|先不|先别|别管|不用管|搁置|暂停|不做了|先不做|不用了)/;
+const OLD_WORK_ACTION = /(继续|接着|再改|改成|改一下|调整|优化|改改|开头|结尾|结构|节奏|语气|口吻|文案|措辞|细节|版本)/;
+/** 创作类与工程类任务的默认判断不同；同一主题从写口播切到排查代码，不能沿用旧栏目。 */
+const CONTENT_INTENT = /(口播|拍摄|录制|剪辑|文案|封面|字幕|直播|视频|选题|脚本|一期|栏目)/;
+const ENGINEERING_INTENT = /(代码|排查|故障|部署|调试|重构|接口|数据库|查询|报错|日志|服务|环境|依赖|测试|配置|修复)/;
+/** 这些词描述的是旧稿的某个方面，不是新对象；不该因为它们出现就撤销旧范围。 */
+const ASPECT_NOISE = /(节奏|速度|风格|语气|口吻|结构|长度|时长|篇幅|配色|字号|字体|标题|文案|措辞|逻辑|细节|开头|结尾|过渡|画面|镜头|音乐|音效|字幕|参数|格式|排版)/g;
+/** 程度、指代和虚词组成的二字片段不是对象证据。 */
+const GENERIC_CHARS = /[再更稍很太挺点些快慢多少好坏大小高低长短早晚新旧一二三四五六七八九十百千万个把的得地了着过吗呢吧啊]/;
 function taskTerms(value) {
-  const plain = text(value, 200).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').replace(TASK_NOISE, ' ').replace(/\s+/g, ' ').trim();
+  const plain = text(value, 200).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').replace(ASPECT_NOISE, ' ').replace(TASK_NOISE, ' ').replace(/\s+/g, ' ').trim();
   const terms = new Set();
   for (const word of plain.match(/[a-z][a-z0-9_-]{2,}/g) || []) terms.add(word);
   const runs = plain.match(/[\u4e00-\u9fff]+/g) || [];
@@ -29,7 +39,8 @@ function taskTerms(value) {
     if (TASK_STOP.has(run)) continue;
     for (let i = 0; i + 2 <= run.length; i += 1) {
       const gram = run.slice(i, i + 2);
-      if (!TASK_STOP.has(gram)) terms.add(gram);
+      if (TASK_STOP.has(gram) || GENERIC_CHARS.test(gram)) continue;
+      terms.add(gram);
     }
   }
   return terms;
@@ -37,19 +48,28 @@ function taskTerms(value) {
 /** 继承旧任务要有正面证据：新要求与本轮任务没有实质对象交集时，先按新任务处理。 */
 export function looksLikeNewTask(query, previousText) {
   const current = text(query, 200);
-  if (!current || isThanks(current) || isRevision(current)) return false;
+  if (!current || isThanks(current)) return false;
   const next = taskTerms(current);
   const previous = taskTerms(previousText);
   const cue = isContinuation(current) || REFERENCE_WORDS.test(current);
   /** 只剩指代或续接词时，必须另有动作才算续接；否则宁可换任务也不沿用旧范围。 */
   if (!next.size) return cue ? !CONTINUATION_ACTION.test(current) : false;
   if (!previous.size) return false;
+  /** 同一主题换了工作类型（口播 → 排查代码）是新任务，不靠对象词重叠判续作。 */
+  const nextKind = CONTENT_INTENT.test(current) ? (ENGINEERING_INTENT.test(current) ? '' : 'content')
+    : (ENGINEERING_INTENT.test(current) ? 'engineering' : '');
+  const previousKind = CONTENT_INTENT.test(previousText) ? (ENGINEERING_INTENT.test(previousText) ? '' : 'content')
+    : (ENGINEERING_INTENT.test(previousText) ? 'engineering' : '');
+  if (nextKind && previousKind && nextKind !== previousKind) return true;
   for (const term of next) if (previous.has(term)) return false;
-  /** 只有指代或「继续」时，还要有明确的新对象动作、转向词或新英文对象才换任务。 */
-  if (!cue) return true;
-  if (NEW_OBJECT_VERB.test(current) || NEW_TASK_MARKER.test(current)) return true;
-  for (const term of next) if (/^[a-z]/.test(term)) return true;
-  return false;
+  /** 指向旧稿还要有继续改它的动作；「旧稿先放着」「这版数据库配置怎么改」都算新任务。 */
+  if (OLD_WORK_REFERENCE.test(current) && !OLD_WORK_PAUSE.test(current) && OLD_WORK_ACTION.test(current)) return false;
+  /**
+   * 有实质对象词却跟旧任务没有任何交集：这就是新任务，不因为句首带了
+   * 「继续」「这个」就把旧范围连同正文一起搬过来。继承只认对象交集、
+   * 明确的旧稿指代，或者除动作/指代外没有新对象（上面两条）。
+   */
+  return true;
 }
 
 export function emptyTasks() {
@@ -76,6 +96,27 @@ export function isRevision(query) {
   return REVISE_WORDS.test(text(query, 160));
 }
 
+const NEGATED_SERIES = /(不要|不用|别|不按|不照|不是|并非|先不|不做|不搞|忽略|跳过|不管|别提)[^，。；！？\n]{0,10}$/;
+const MENTION_SERIES = /(日志|报错|错误|信息|提到|说到|包含|关键词|这个词|源码|代码|插件|文档|规则名|栏目名|分析)[^，。；！？\n]{0,10}$/;
+const PAUSED_SERIES = /^(先放着|先放|放一边|先不做|不做了|不用了|暂停)/;
+const PAUSED_BEFORE = /(先放着|先放|放一边|先不做|不做了|不用了|暂停)[^，。；！？\n]{0,4}$/;
+/** 提到栏目名不等于选中它：否定、引用、看源码或「先放着」都只是话题，不能建绑定。 */
+export function seriesChosenBy(query, series) {
+  const value = text(query, 400);
+  const name = text(series, 40);
+  if (!value || !name) return false;
+  let from = 0;
+  while (from <= value.length) {
+    const at = value.indexOf(name, from);
+    if (at < 0) return false;
+    const before = value.slice(Math.max(0, at - 14), at);
+    const after = value.slice(at + name.length);
+    if (!NEGATED_SERIES.test(before) && !MENTION_SERIES.test(before) && !PAUSED_BEFORE.test(before) && !PAUSED_SERIES.test(after)) return true;
+    from = at + name.length;
+  }
+  return false;
+}
+
 export function requestBatchKey(messageIds) {
   const ids = [...new Set((Array.isArray(messageIds) ? messageIds : []).map((id) => String(id || '')).filter(Boolean))].sort();
   if (!ids.length) return '';
@@ -271,7 +312,7 @@ export function routeTask(tasksInput, input = {}) {
   }
   const registered = (Array.isArray(input.registeredSeries) ? input.registeredSeries : []).map((item) => text(item, 40)).filter(Boolean);
   /** 用户在这句话里点名的栏目优先于旧栏目和项目默认值。 */
-  const namedSeries = registered.find((series) => series && query.includes(series)) || '';
+  const namedSeries = registered.find((series) => seriesChosenBy(query, series)) || '';
   const changedSeries = current && namedSeries && namedSeries !== (current.seriesId || '') ? namedSeries : '';
   const fallbackKind = (currentEpisode && currentEpisode.taskKind)
     || (input.defaults && input.defaults.taskKind) || '';
@@ -311,9 +352,10 @@ export function routeTask(tasksInput, input = {}) {
     return { tasks, anchor: current, episode: currentEpisode, decision: { kind: 'none', reason: 'thanks', pointer: true }, changed: false };
   }
 
-  /** 先认新对象，再认续作：带「继续 / 这个」但换了对象，也必须撤销旧范围。 */
+  /** 先认新对象，再认续作：带「继续 / 这个」但换了对象，也必须撤销旧范围。
+   *  本句点名了已登记栏目（「再做一期口播」）就是明确的对象证据，不算换任务。 */
   if (current && currentEpisode && currentEpisode.status !== 'unbound'
-    && !SWITCH_WORDS.test(query) && !changedSeries
+    && !SWITCH_WORDS.test(query) && !changedSeries && !namedSeries
     && looksLikeNewTask(query, currentEpisode.taskText || '')) {
     const transitionId = transitionIdFor(batchKey, tasks.revision);
     const existing = Object.values(tasks.episodes).find((episode) => episode.transitionId === transitionId);

package/client.js

@@ -852,7 +852,7 @@ window.__ModuleLoader__.load({
       const unresolved = rule.applicability === 'unresolved'
         || (rule.applicability === 'conditional' && (!Array.isArray(rule.conditions) || rule.conditions.length === 0));
       if (unresolved) return '适用范围待确认，暂不参与回答。';
-      if (rule.state === 'pending') return '尚未参与回答，确认后才会试用。';
+      if (rule.state === 'pending') return '还没生效，采纳后才参与回答。';
       if (rule.state === 'trial') return '在条件匹配的任务中参与参考，到期后暂停。';
       if (rule.state === 'active') return '在适用任务中作为默认参考，当前明确要求优先。';
       return '';
@@ -865,7 +865,7 @@ window.__ModuleLoader__.load({
         if (conditions.length === 0) return '待确认';
         return conditions.map((item) => `${CONDITION_LABEL[item.key] || item.key} ${item.value}`).join('、');
       }
-      return '所有项目';
+      return '本项目内';
     };
 
     const evidenceTextOf = (row) => {
@@ -1267,7 +1267,7 @@ window.__ModuleLoader__.load({
           h(Toggle, { ariaLabel: '自进化', on: Boolean(memoryOn && evolution && evolution.enabled === true), busy: busy || !evolution || !canToggle || !memoryOn, onClick: canToggle && memoryOn ? toggleEvolution : undefined }),
         ),
         h('div', { style: PANEL_MUTED }, '从反馈中整理经验，按需使用'), // ui-copy-ignore 用户指定文案
-        h('div', { style: PANEL_MUTED }, '实验功能'), // ui-copy-ignore 用户指定文案
+        h('div', { style: PANEL_MUTED }, '实验功能，会增加 token 消耗'), // ui-copy-ignore 用户指定文案
       );
       const switchBar = h('div', { style: { display: 'flex', alignItems: 'stretch', gap: '10px', flexWrap: 'wrap', padding: '12px 18px', borderBottom: '1px solid var(--dsw-alias-border-l1)', flex: '0 0 auto' } },
         globalView ? h('div', { style: { ...PANEL_MUTED, padding: '2px 0' } }, '全局记忆只读') : memorySwitch,
@@ -1528,14 +1528,16 @@ window.__ModuleLoader__.load({
       const groups = React.useMemo(() => {
         const list = Array.isArray(refs) ? refs : EMPTY;
         return {
-          reference: list.filter((item) => item.exposure === 'reference'),
+          found: list.filter((item) => item.exposure === 'reference' && item.kind === 'memory-search'),
+          provided: list.filter((item) => item.exposure === 'reference' && item.kind === 'memory-read'),
           update: list.filter((item) => item.exposure === 'update'),
         };
       }, [refs]);
       if (!sessionId && refs.length === 0) return null;
-      if (groups.reference.length === 0 && groups.update.length === 0) return null;
+      if (groups.found.length === 0 && groups.provided.length === 0 && groups.update.length === 0) return null;
       return h('div', { style: TAIL },
-        h(RefSection, { label: '本轮参考', items: groups.reference, sessionId, turnKey: turn }),
+        h(RefSection, { label: '检索发现', items: groups.found, sessionId, turnKey: turn }),
+        h(RefSection, { label: '已提供正文', items: groups.provided, sessionId, turnKey: turn }),
         h(RefSection, { label: '本轮更新', items: groups.update, sessionId, turnKey: turn }),
       );
     };

package/docs/RELEASE-0.16.0.md

@@ -0,0 +1,10 @@
+# 0.16.0
+
+- 任务切换不再把上一条任务的规则带进新任务：带明确对象的新要求按新任务处理，只有「继续改」这类没有对象的短句才继承。
+- 自进化关掉或换代后，已经准备好的实验正文和 `contextId` 立即失效；重新打开也不复活旧正文。
+- 试用到期的学习结果不再自动注入，检索、读取、自动注入共用同一档可用性判断。
+- 检索先过滤不可用条目再截断，不会被待确认的候选挤掉真正的命中；只有待确认候选时明确返回「适用条件还没确认」。
+- 写入口径放宽：正文上限 4096 字节，整库 1 MB；摘要超长自动截断；不再因为正文提到像素、字号或写成指令句而拒绝保存。
+- 只改标题的学习规则保持 `active` 和已有证据，不再降成试用。
+- 容量腾挪不归档用户固定过的规则；实验规则与待确认候选的额度不再重复计数。
+- 面板：作用范围改成「本项目内」，候选状态与引用分组的文案对齐实际行为，自进化开关标明会增加消耗。

package/index.js

@@ -635,8 +635,8 @@ const SAVE_PARAMS = {
   properties: {
     id: { type: 'string', description: '要更新的记忆 id（来自搜索结果或相近提示）。同一件事更新时用它，别另建一条' },
     title: { type: 'string', description: `标题：名词短语，用户一眼能认出是哪件事，不超过 ${LIMITS.titleChars} 字。它就是这条记忆的身份` },
-    summary: { type: 'string', description: `一句话说清要记的内容本身——用户只看这一行决定留不留，名词短语，不超过 ${LIMITS.summaryChars} 字` },
-    body: { type: 'string', description: `正文 markdown，整段替换旧正文，不超过 ${LIMITS.entryBytes} 字节。只写原则、判断规则、触发条件和边界；不写像素、字号、层级、颜色、一次性数字或代码片段，这些查当前代码或文档。` },
+    summary: { type: 'string', description: `一句话说清要记的内容本身——用户只看这一行决定留不留，名词短语最好，超长会自动截到这个长度` },
+    body: { type: 'string', description: `正文 markdown，整段替换旧正文，不超过 ${LIMITS.entryBytes} 字节。只写原则、判断规则、触发条件和边界；不写一次性数字或代码片段，这些查当前代码或文档。` },
     when: { type: 'string', description: `前置条件或适用场景（「在哪台机器 / 哪个环境 / 什么情况下」），不超过 ${LIMITS.whenChars} 字。同一标题但前置条件不同，会存成两条，不合并；更新时不给就保留原值` },
     kind: { type: 'string', enum: ['preference', 'convention', 'procedure', 'pointer', 'pitfall', 'credential_hint', 'note'], description: '条目类型；更新时不给就保留原值' },
     tags: { type: 'array', items: { type: 'string' }, description: '最多 5 个标签；更新时不给就保留原值' },
@@ -1051,6 +1051,14 @@ export function apply(ctx, config) {
     return text;
   }
 
+  /** 实验正文按条目记有效期：一条到期只撤一条，不把同请求里其他规则一起清掉。 */
+  function experimentTextFrom(parts, now = Date.now()) {
+    if (!parts || !Array.isArray(parts.items)) return '';
+    const items = parts.items.filter((item) => !item.validUntil || now <= Date.parse(String(item.validUntil)));
+    if (!items.length) return '';
+    return `${parts.header}\n${items.map((item) => item.line).join('\n')}${parts.tail || ''}`;
+  }
+
   /** 本轮问题与栏目名的字面相关度：只展示有交集的栏目，交集为空就整段跳过。 */
   function relevantRanges(names, query) {
     const text = String(query || '').toLowerCase();
@@ -1070,8 +1078,19 @@ export function apply(ctx, config) {
     });
   }
 
+  /** 实验正文只在「自进化开着，且还是同一代」时可用；关掉再开不能复活旧正文。 */
+  function experimentStillCurrent(scope, held) {
+    let evolution;
+    try { evolution = evolutionStatus(scope); } catch { return false; }
+    if (!evolution || evolution.enabled !== true || evolution.compatible === false) return false;
+    if (held && held.epoch && String(evolution.epoch || '') !== String(held.epoch)) return false;
+    return true;
+  }
+
   /** 读决策 → 一段短提示：未绑定只给栏目索引，已绑定才给规则正文。 */
   function renderExperiment(scope, decision, context, held, win) {
+    if (held && typeof held === 'object') { held.validUntil = ''; held.experimentParts = null; held.injectedIds = []; }
+    if (!experimentStillCurrent(scope, held)) return '';
     if (!decision || decision.kind === 'none') return '';
     if (decision.kind === 'conflict') {
       return chargeExperiment(win, '这些实验规则互相冲突，先按用户这次说的做，别叠加对立的规则。');
@@ -1095,6 +1114,8 @@ export function apply(ctx, config) {
       if (record.reviewState === 'legacy_unreviewed') continue;
       const learning = record.learning && typeof record.learning === 'object' ? record.learning : {};
       if (learning.state !== 'active' && learning.state !== 'trial') continue;
+      /** 试用到期、暂停或身份失效：自动注入与检索、读取用同一档可用性，不能各判各的。 */
+      if (!view.experimentalUsable(record, Date.now())) continue;
       const status = view.statusOf(record, context);
       if (status === 'needs_context') { unknown.push(record); continue; }
       if (status !== 'ok') continue;
@@ -1106,8 +1127,7 @@ export function apply(ctx, config) {
     if (conflict) {
       return chargeExperiment(win, '这些实验规则互相冲突，先按用户这次说的做，别叠加对立的规则。');
     }
-    const lines = [];
-    const shown = [];
+    const parts = { header: EXPERIMENT_RULES_HEADER, items: [], tail: held && held.contextId ? `\ncontextId=${held.contextId}` : '' };
     let used = Buffer.byteLength(EXPERIMENT_RULES_HEADER) + 1;
     for (const record of matched.slice(0, 3)) {
       const body = String(record.body || '');
@@ -1123,17 +1143,24 @@ export function apply(ctx, config) {
       const size = Buffer.byteLength(`\n${line}`);
       if (used + size > EXPERIMENT_BYTES) break;
       used += size;
-      lines.push(line);
-      shown.push(record.id);
+      const trialLearning = record.learning && typeof record.learning === 'object' ? record.learning : {};
+      const trialUntil = trialLearning.state === 'trial' && Number.isFinite(Date.parse(String(trialLearning.trialUntil || '')))
+        ? String(trialLearning.trialUntil) : '';
+      parts.items.push({ id: record.id, line, validUntil: trialUntil });
+    }
+    if (held) held.injectedIds = parts.items.map((item) => item.id);
+    if (!parts.items.length && unknown.length) {
+      /** 条件没确认的条目只报数量，绝不在模型侧暴露标题。 */
+      return chargeExperiment(win, '有些实验规则的适用条件还没确认，先按用户这次说的做，别把它们当本轮依据。');
     }
-    if (held) held.injectedIds = shown;
-    if (!lines.length && unknown.length) {
-      const nameLine = unknown.slice(0, 3).map((record) => `- 「${record.title}」 · ${record.id}`).join('\n');
-      return chargeExperiment(win, `有些实验规则的适用条件还没确认，先别当成本轮依据：\n${nameLine}`);
+    if (!parts.items.length) return '';
+    if (held) held.experimentParts = parts;
+    /** 兼容旧读取点：整体最早到期只取本轮真正注入的条目，不再被无关试验拖下水。 */
+    if (held) {
+      const deadlines = parts.items.map((item) => Date.parse(String(item.validUntil))).filter(Number.isFinite);
+      if (deadlines.length) held.validUntil = new Date(Math.min(...deadlines)).toISOString();
     }
-    if (!lines.length) return '';
-    const tail = held && held.contextId ? `\ncontextId=${held.contextId}` : '';
-    return chargeExperiment(win, `${EXPERIMENT_RULES_HEADER}\n${lines.join('\n')}${tail}`);
+    return chargeExperiment(win, experimentTextFrom(parts));
   }
 
   /** 一次真人请求只路由一次；同一批次重试复用同一 transitionId。 */
@@ -1240,7 +1267,7 @@ export function apply(ctx, config) {
     const contextId = anchor.contextIdFor(scope.key, batchKey, crypto.randomUUID().slice(0, 8));
     const created = {
       contextId, projectKey: scope.key, sessionId: win.sessionId, batchKey,
-      messageIds: win.messageIds.slice(), context: view.trustedContext(scope, {}),
+      messageIds: win.messageIds.slice(), query: trustedQueryOf(win), context: view.trustedContext(scope, {}),
       anchor: null, ranges: rangesOf(scope), decision: { kind: 'none' }, epoch: status.epoch, at: Date.now(),
     };
     win.experiment = created;
@@ -1248,13 +1275,27 @@ export function apply(ctx, config) {
     return contextId;
   }
 
+  /** 本轮真人消息是唯一可信的任务依据；模型自己写的 query 只用于检索词，不能拿来建绑定。 */
+  function trustedQueryOf(win) {
+    return win && typeof win.query === 'string' ? win.query : '';
+  }
+
   /** 前台绑定只升到 proposed：真正执行链还没发生，不冒充 active。 */
-  function bindSelection(execution, resolved, query) {
+  function bindSelection(execution, resolved) {
     const held = resolved.held;
+    if (!held || typeof held !== 'object') return { ok: false, status: 'needs_context', reason: '本轮还没有可核对的用户消息，先重新问一次当前任务' };
+    const query = held.query || trustedQueryOf(resolved.win);
+    if (!query) return { ok: false, status: 'needs_context', reason: '本轮还没有可核对的用户消息，先重新问一次当前任务' };
     const ranges = held.ranges || { series: [], taskKinds: [] };
+    /** 自动路由已经选了范围就沿用同一个结果，工具绑定不重新猜一遍，避免两处给出不同任务。 */
+    const routedAnchor = held.anchor && typeof held.anchor === 'object' ? held.anchor : null;
     const hits = [];
-    for (const value of ranges.series || []) if (query.includes(value)) hits.push({ seriesId: value });
-    for (const value of ranges.taskKinds || []) if (query.includes(value)) hits.push({ taskKind: value });
+    if (routedAnchor && routedAnchor.seriesId) hits.push({ seriesId: routedAnchor.seriesId });
+    else if (routedAnchor && routedAnchor.taskKind) hits.push({ taskKind: routedAnchor.taskKind });
+    else {
+      for (const value of ranges.series || []) if (anchor.seriesChosenBy(query, value)) hits.push({ seriesId: value });
+      for (const value of ranges.taskKinds || []) if (anchor.seriesChosenBy(query, value)) hits.push({ taskKind: value });
+    }
     if (hits.length !== 1) {
       const names = [...(ranges.series || []), ...(ranges.taskKinds || [])].slice(0, 3);
       return { ok: false, status: 'needs_context', reason: names.length ? '本轮没有匹配的记忆范围，按当前任务继续' : '本轮没有适用的记忆范围，按当前任务继续' };
@@ -1276,7 +1317,11 @@ export function apply(ctx, config) {
     resolved.context = held.context;
     const text = renderExperiment(resolved.scope, held.decision, held.context, held, resolved.win);
     const preparedState = prepared.get(execution && execution.agent);
-    if (preparedState) preparedState.experimentText = text;
+    if (preparedState) {
+      preparedState.experimentText = text;
+      preparedState.experimentParts = held.experimentParts || null;
+      preparedState.validUntil = held.validUntil || '';
+    }
     return { ok: true };
   }
 
@@ -1297,7 +1342,17 @@ export function apply(ctx, config) {
       if (!memoryEnabled(scope)) return '';
       const epoch = controlStatus(scope).epoch || '';
       if (state.controlEpoch && epoch && state.controlEpoch !== epoch) return '';
-      return [state.experimentText, state.text].filter(Boolean).join('\n\n');
+      /** 自进化关掉或换过代：关掉前的实验正文不再输出，重开也不复活。 */
+      let evolutionText = state.experimentParts ? experimentTextFrom(state.experimentParts) : state.experimentText;
+      if (evolutionText) {
+        let evolution;
+        try { evolution = evolutionStatus(scope); } catch { evolution = null; }
+        if (!evolution || evolution.enabled !== true || evolution.compatible === false
+          || (state.evolutionEpoch && String(evolution.epoch || '') !== state.evolutionEpoch)) evolutionText = '';
+      }
+      /** 没有逐条快照时才退回整段到期判断；有快照就只撤到期的那一条。 */
+      if (evolutionText && !state.experimentParts && state.validUntil && Date.now() > Date.parse(String(state.validUntil))) evolutionText = '';
+      return [evolutionText, state.text].filter(Boolean).join('\n\n');
     } catch {
       return '';
     }
@@ -1328,6 +1383,8 @@ export function apply(ctx, config) {
           title: { type: 'string' },
           summary: { type: 'string' },
           when: { type: 'string' },
+          summaryShortened: { type: 'boolean' },
+          fullTextInBody: { type: 'boolean' },
           revision: { type: 'integer' },
           merged: { type: 'boolean' },
           changed: { type: 'boolean' },
@@ -1361,7 +1418,7 @@ export function apply(ctx, config) {
           ? `memory · 需要确认：「${value.title}」与已有条目相近${value.crossLayer ? '（在另一层）' : ''}${value.sameTopic ? '（同一主题槽位）' : ''}\n${value.similar}\n要更新它，用 id 重存；确实是另一条，加 resolution="distinct"`
           : value.changed === false
             ? `memory · unchanged ${withTag(value, `"${value.title}"`)} · ${value.id}`
-            : `memory · ${value.merged ? 'merged' : 'saved'} ${withTag(value, `"${value.title}"`)}${value.when ? `（${value.when}）` : ''} · ${value.id}${value.similar ? ` · 相近：${value.similar}` : ''}${value.archived ? ` · 已归档「${value.archived}」腾位` : ''}`,
+            : `memory · ${value.merged ? 'merged' : 'saved'} ${withTag(value, `"${value.title}"`)}${value.when ? `（${value.when}）` : ''} · ${value.id}${value.similar ? ` · 相近：${value.similar}` : ''}${value.archived ? ` · 已归档「${value.archived}」腾位` : ''}${value.fullTextInBody ? ' · 摘要超过 60 字，完整原句已存进正文' : ''}`,
       }],
     },
     execute: async (args, execution) => {
@@ -1439,6 +1496,8 @@ export function apply(ctx, config) {
         title: saved.record.title,
         summary: saved.record.summary,
         when: saved.record.when || '',
+        summaryShortened: Boolean(saved.draft?.summaryShortened),
+        fullTextInBody: Boolean(saved.draft?.fullTextInBody),
         revision: saved.record.revision || 1,
         merged: saved.merged,
         changed: !saved.noop,
@@ -1507,6 +1566,7 @@ export function apply(ctx, config) {
           chars: { type: 'integer' },
           text: { type: 'string' },
           status: { type: 'string', enum: ['ok', 'budget_exhausted', 'memory_disabled', 'needs_context'] },
+          reasonCode: { type: 'string' },
           refs: {
             type: 'array',
             items: {
@@ -1553,19 +1613,20 @@ export function apply(ctx, config) {
       const resolved = resolveRequestContext(execution, contextId);
       if (!resolved.ok) return { count: 0, chars: 0, text: resolved.reason, status: resolved.status || 'needs_context', refs: [] };
       if (wantsBind) {
-        const bound = bindSelection(execution, resolved, String(args.query || ''));
+        const bound = bindSelection(execution, resolved);
         if (!bound.ok) return { count: 0, chars: 0, text: bound.reason, status: bound.status || 'needs_context', refs: [] };
       }
       const scope = resolved.scope;
       const context = resolved.context;
-      /** 检索只列当前任务真能用的条目；条件未知或不适用就只留状态，不给索引行。 */
-      const hits = search(scope, args.query, (args.limit ?? 3) + 3, {
+      /** 检索只列当前任务真能用的条目；先取全量候选，过滤后再截断，避免不可用条目挤掉后面的命中。 */
+      const limit = args.limit ?? 3;
+      const rawHits = search(scope, args.query, 50, {
         context,
         history: args.history === true,
         allowExperimental: resolved.experimental === true,
-      }).filter((item) => (item.archived || item.status === 'ok')
-        && (!item.ownerProjectId || item.ownerProjectId === scope.key))
-        .slice(0, args.limit ?? 3);
+      }).filter((item) => !item.ownerProjectId || item.ownerProjectId === scope.key);
+      const hits = rawHits.filter((item) => item.archived || item.status === 'ok').slice(0, limit);
+      const withheld = rawHits.filter((item) => !item.archived && item.status !== 'ok');
       const scopeName = scope.key === 'global' ? '' : projectNameOf(scope);
       const shown = hits.map((item) => ({
         ...view.toModelView(item, 'search', { status: item.status || (item.archived ? 'archived' : 'ok') }),
@@ -1575,6 +1636,27 @@ export function apply(ctx, config) {
         const rendered = renderIndex(shown.slice(0, kept));
         return { count: kept, chars: rendered.chars, text: rendered.text, status: 'ok', refs: refsOf(hits.slice(0, kept)) };
       };
+      /** 有匹配但当前用不上：只说状态，不把标题、编号或旧规则递给模型，避免它被这些字面带偏。 */
+      if (!hits.length && withheld.length) {
+        const unresolved = withheld.some((item) => item.status === 'needs_context');
+        const value = {
+          count: 0,
+          chars: 0,
+          text: unresolved
+            ? '有相关的项目记忆，但适用条件还没确认。先说明当前任务，或确认这条记忆的适用范围。'
+            : '有相关的项目记忆，但当前任务明确不适用。',
+          status: unresolved ? 'needs_context' : 'ok',
+          reasonCode: unresolved ? 'applicability_unresolved' : 'not_applicable',
+          refs: [],
+        };
+        if (win) {
+          const bytes = jsonBytes(value);
+          if (!affordable(win, bytes)) return { ...value, status: 'budget_exhausted', text: '' };
+          win.bytes += bytes;
+          win.reads += 1;
+        }
+        return value;
+      }
       /** 没命中是正常结果，不是额度问题；空响应同样记一次本请求开销。 */
       if (!hits.length) {
         const empty = { count: 0, chars: 0, text: '', status: 'ok', refs: [] };
@@ -1632,10 +1714,20 @@ export function apply(ctx, config) {
           : value.status === 'memory_disabled'
             ? 'memory · 记忆检索已关闭'
             : value.repeat
-              ? `memory · 本请求已读过「${value.title}」 · ${value.id}`
+              ? 'memory · 本请求已读过这条记忆'
               : value.body
                 ? `memory · ${withTag(value, `「${value.title}」`)}${value.when ? `（${value.when}）` : ''} · ${value.id}${statusLabel(value.status)}\n${value.body}`
-                : `memory · 「${value.title}」的相关记忆\n${value.links || '(无)'}`,
+                : value.links !== undefined && value.status === 'ok'
+                  ? `memory · 「${value.title}」的相关记忆\n${value.links || '(无)'}`
+                  : value.status === 'needs_context'
+                    ? 'memory · 这条记忆的适用条件还没确认'
+                    : value.status === 'not_applicable'
+                      ? 'memory · 这条记忆不适用于当前任务'
+                      : value.status === 'archived'
+                        ? 'memory · 这条记忆已归档'
+                        : value.status === 'gone'
+                          ? 'memory · 这条记忆已不存在'
+                          : 'memory · 当前不能读这条记忆',
       }],
       presentationMeta: (_args, value) => ({
         kind: 'memory-read',
@@ -1661,7 +1753,7 @@ export function apply(ctx, config) {
         const found = readLinks(scope, args.id, { context, allowExperimental });
         if (!found) throw new Error(`没有 ${args.id} 这条记忆`);
         if (found.status !== 'ok') {
-          const withheld = { id: found.id, scope: found.scope, status: found.status, links: '' };
+          const withheld = { id: '', scope: '', status: found.status, links: '' };
           if (win) {
             const bytes = jsonBytes(withheld);
             if (!affordable(win, bytes)) return { id: '', scope: '', status: 'budget_exhausted' };
@@ -1687,22 +1779,22 @@ export function apply(ctx, config) {
       const record = readEntry(scope, args.id, { context, allowExperimental });
       if (!record) throw new Error(`没有 ${args.id} 这条记忆`);
       if (record.origin === 'project_evolution' && record.ownerProjectId && record.ownerProjectId !== scope.key) {
-        return { id: args.id, title: record.title, when: record.when || '', revision: record.revision || 1, scope: record.scope, status: 'not_applicable', body: '' };
+        return { id: '', scope: record.scope, status: 'not_applicable', body: '' };
       }
       if (record.origin === 'project_evolution' && !allowExperimental) {
-        return { id: record.id, title: record.title, when: record.when || '', revision: record.revision || 1, scope: record.scope, status: 'needs_context', body: '' };
+        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
       }
-      /** 暂停、过期或条件不匹配的实验条目只给状态，不给正文。 */
+      /** 暂停、过期或条件不匹配的实验条目只给状态，不给标题和正文。 */
       if (record.origin === 'project_evolution' && !view.experimentalUsable(record)) {
-        return { id: record.id, title: record.title, when: record.when || '', revision: record.revision || 1, scope: record.scope, status: 'needs_context', body: '' };
+        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
       }
       const learningState = record.learning && typeof record.learning === 'object' ? record.learning : {};
       if (record.origin === 'project_evolution' && (learningState.state === 'paused' || learningState.blockedReason)) {
-        return { id: record.id, title: record.title, when: record.when || '', revision: record.revision || 1, scope: record.scope, status: 'needs_context', body: '' };
+        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
       }
-      /** 条件未知或不适用的条目只报状态：正文绝不能绕过自动召回的门槛。 */
+      /** 条件未知或不适用的条目只报状态：正文和标题都不能绕过自动召回的门槛。 */
       if (record.status !== 'ok') {
-        return { id: record.id, title: record.title, when: record.when || '', revision: record.revision || 1, scope: record.scope, status: record.status === 'needs_context' ? 'needs_context' : 'not_applicable', body: '' };
+        return { id: '', scope: record.scope, status: record.status === 'needs_context' ? 'needs_context' : 'not_applicable', body: '' };
       }
       const revision = record.revision || 1;
       const body = String(record.body ?? '');
@@ -1936,6 +2028,8 @@ export function apply(ctx, config) {
               previous.text = snapshot ? snapshot.text : '';
               previous.cards = snapshot ? snapshot.cards : [];
               previous.experimentText = experimentText;
+              previous.experimentParts = win && win.experiment ? (win.experiment.experimentParts || null) : null;
+              previous.validUntil = win && win.experiment ? (win.experiment.validUntil || '') : '';
               previous.fingerprint = fingerprint;
             } else {
               clearPrepared(agent);
@@ -1948,13 +2042,15 @@ export function apply(ctx, config) {
       /** 工具模式也要开额度窗口：只是不自动注入，工具调用同样受每请求预算约束。 */
       const ids = fresh.map((message) => String(message?.id ?? '')).filter(Boolean).sort();
       const win = openWindow(agent, { sessionId, turn, messageIds: ids });
+      /** 工具模式也要记下本轮真人原话：只用于核对绑定，不自动注入。 */
+      const query = view.newestUserQuery(fresh).slice(0, RECALL_QUERY_CHARS);
+      if (win && query) win.query = query;
 
       if (recallMode() !== 'adaptive') {
         clearPrepared(agent);
         return decision;
       }
 
-      const query = view.newestUserQuery(fresh).slice(0, RECALL_QUERY_CHARS);
       if (!query) {
         clearPrepared(agent);
         return decision;
@@ -1995,9 +2091,13 @@ export function apply(ctx, config) {
         clearPrepared(agent);
         return decision;
       }
+      let evolutionEpoch = '';
+      try { evolutionEpoch = String(evolutionStatus(scope).epoch || ''); } catch { evolutionEpoch = ''; }
       const state = {
         text: snapshot ? snapshot.text : '',
         experimentText: experiment ? experiment.text : '',
+        experimentParts: experiment && experiment.held ? (experiment.held.experimentParts || null) : null,
+        validUntil: experiment && experiment.held ? (experiment.held.validUntil || '') : '',
         cards: snapshot ? snapshot.cards : [],
         query,
         sessionId,
@@ -2005,6 +2105,7 @@ export function apply(ctx, config) {
         signal,
         fingerprint,
         controlEpoch,
+        evolutionEpoch,
         at: Date.now(),
       };
       prepared.set(agent, state);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.15.0",
+  "version": "0.16.2",
   "description": "On-demand memory for the DeepSeek Harness: nothing in the system prompt, one muted line only when something is saved, hit or suggested.",
   "type": "module",
   "main": "index.js",

package/state.js

@@ -182,9 +182,9 @@ export const LIMITS = {
   entries: 200,
   globalEntries: 200,
   hardEntries: 1000,
-  entryBytes: 1200,
+  entryBytes: 4096,
   recordBytes: 10 * 1024,
-  totalBytes: 512 * 1024,
+  totalBytes: 1024 * 1024,
   historyBytes: 512 * 1024,
   stateBytes: 2 * 1024 * 1024,
   titleChars: 60,
@@ -747,10 +747,12 @@ export function enforceBudget(state, scope) {
     const active = state.entries.filter((entry) => entry.status === 'active');
     const bytes = active.reduce((sum, entry) => sum + entryBytesOf(entry), 0);
     if (active.length <= LIMITS.hardEntries && bytes <= LIMITS.totalBytes) break;
-    const idle = active.filter((entry) => now - entryLastTouch(entry) >= IDLE_MS);
-    const pool = idle.length ? idle : active;
+    /** 用户固定过的规则不参与容量腾挪；只从没固定的条目里选最久没读的。 */
+    const movable = active.filter((entry) => entry.maintenance?.learning?.pinned !== true);
+    if (!movable.length) throw new StateError('budget_exhausted', '记忆库已满，固定住的规则不参与腾挪：先取消固定或精简正文');
+    const idle = movable.filter((entry) => now - entryLastTouch(entry) >= IDLE_MS);
+    const pool = idle.length ? idle : movable;
     const victim = pool.reduce((oldest, entry) => (entryLastTouch(entry) < entryLastTouch(oldest) ? entry : oldest));
-    if (!victim) throw new StateError('budget_exhausted', `记忆库已满：这一条自己就超过 ${LIMITS.totalBytes} 字节正文预算，先精简正文`);
     victim.status = 'archived';
     victim.updatedAt = new Date().toISOString();
     evicted.push({ id: victim.id, title: victim.current.title });