dsh-lite-memory 0.15.0 → 0.16.4

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 '';
     }
@@ -1306,7 +1361,7 @@ export function apply(ctx, config) {
 
   ctx.effect(() => tools.register({
     name: 'memory_save',
-    description: `保存一条记忆。只在会改变以后判断时才存；先搜已有条目，能更新就不要新建。保存前先蒸馏：标题是结论，正文只写原则与触发条件，不抄原始输出里的具体数值。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。更新同一件事时带 id：身份只看标题、旧标题和前置条件，像不像不授权覆盖。文本相近但标题不同时先不写，返回 needsResolution 与 1–2 条相近条目：确实是同一条就用那个 id 更新，确实是另一条才带 resolution="distinct" 再存。带 id 更新时没给的字段保持原值，正文整段替换，旧正文只留作内部撤回，不展示也不参与检索。条数到硬上限时把同层最久没被读的一条移进归档，结果里写明动了哪条，不拒绝新记忆；单条正文超限只报错、不截断。前置条件不同的同一标题是两条。${NOTES}`,
+    description: `保存一条记忆。只在会改变以后判断时才存；先搜已有条目，能更新就不要新建。保存前先蒸馏：标题是结论，正文只写原则与触发条件，通常 2–4 句；路径、字段表、完整命令、版本号、尺寸数值不要抄进正文，改成文档或 skill 的指针。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。更新同一件事时带 id：身份只看标题、旧标题和前置条件，像不像不授权覆盖。文本相近但标题不同时先不写，返回 needsResolution 与 1–2 条相近条目：确实是同一条就用那个 id 更新，确实是另一条才带 resolution="distinct" 再存。带 id 更新时没给的字段保持原值，正文整段替换，旧正文只留作内部撤回，不展示也不参与检索。条数到硬上限时把同层最久没被读的一条移进归档，结果里写明动了哪条，不拒绝新记忆；单条正文超限只报错、不截断。前置条件不同的同一标题是两条。${NOTES}`,
     parameters: SAVE_PARAMS,
     output: {
       presentationMeta: (_args, value) => ({
@@ -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);
@@ -2149,7 +2250,7 @@ export function apply(ctx, config) {
       if (sawTool) throw new Error('整理返回了工具调用');
       /** 运行期间用户又给了新反馈：旧结果不能覆盖新纠正，直接作废，等排队的下一次整理。 */
       if ((feedbackRevisions.get(scope.key) || 0) !== candidate.feedbackRevision) {
-        throw new Error('反馈已更新，这次整理作废');
+        throw new Error('反馈已更新，这轮结果没采用');
       }
       const parsed = learning.parseOutput(text, { finish, refs: input.refs, rules: input.rules, ranges });
       if (!parsed.ok) throw new Error(parsed.reason);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.15.0",
+  "version": "0.16.4",
   "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 });